// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: pb/fiee/cast.proto

package cast

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

	"google.golang.org/protobuf/types/known/anypb"
)

// 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)
	_ = anypb.Any{}
	_ = sort.Sort
)

// Validate checks the field values on AsInfo with the rules defined in the
// proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *AsInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on AsInfo with the rules defined in the
// proto definition for this message. If any rules are violated, the result is
// a list of violation errors wrapped in AsInfoMultiError, or nil if none found.
func (m *AsInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *AsInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ProfileKey

	// no validation rules for AsID

	if len(errors) > 0 {
		return AsInfoMultiError(errors)
	}

	return nil
}

// AsInfoMultiError is an error wrapping multiple validation errors returned by
// AsInfo.ValidateAll() if the designated constraints aren't met.
type AsInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m AsInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m AsInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e AsInfoValidationError) 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 %sAsInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = AsInfoValidationError{}

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

// Validate checks the field values on MediaUserListReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *MediaUserListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaUserListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaUserListReqMultiError, or nil if none found.
func (m *MediaUserListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaUserListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistVal

	// no validation rules for ManagerVal

	// no validation rules for PlatformUserName

	// no validation rules for PlatformID

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for ArtistUuid

	// no validation rules for CreateStartDate

	// no validation rules for CreateEndDate

	// no validation rules for AuthStatus

	// no validation rules for MediaUserID

	// no validation rules for NeedStats

	// no validation rules for NeedAsInfo

	// no validation rules for Expired

	// no validation rules for ExceptionStatus

	if len(errors) > 0 {
		return MediaUserListReqMultiError(errors)
	}

	return nil
}

// MediaUserListReqMultiError is an error wrapping multiple validation errors
// returned by MediaUserListReq.ValidateAll() if the designated constraints
// aren't met.
type MediaUserListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaUserListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaUserListReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaUserListReqValidationError) 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 %sMediaUserListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaUserListReqValidationError{}

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

// Validate checks the field values on MediaUserInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *MediaUserInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaUserInfo with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in MediaUserInfoMultiError, or
// nil if none found.
func (m *MediaUserInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaUserInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PlatformUserName

	// no validation rules for PlatformID

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for ArtistUuid

	// no validation rules for ManagerUserName

	// no validation rules for ManagerUuid

	// no validation rules for MediaAccountUuid

	// no validation rules for CreatedDate

	// no validation rules for AuthStatus

	// no validation rules for PendingVideoCount

	// no validation rules for UploadedVideoCount

	// no validation rules for ReleasedVideoTotal

	// no validation rules for PendingPostCount

	// no validation rules for UploadedPostCount

	// no validation rules for ReleasedPostTotal

	if all {
		switch v := interface{}(m.GetAsInfo()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, MediaUserInfoValidationError{
					field:  "AsInfo",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, MediaUserInfoValidationError{
					field:  "AsInfo",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetAsInfo()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return MediaUserInfoValidationError{
				field:  "AsInfo",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for ArtistSubNum

	// no validation rules for Expired

	// no validation rules for ExceptionStatus

	if len(errors) > 0 {
		return MediaUserInfoMultiError(errors)
	}

	return nil
}

// MediaUserInfoMultiError is an error wrapping multiple validation errors
// returned by MediaUserInfo.ValidateAll() if the designated constraints
// aren't met.
type MediaUserInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaUserInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaUserInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaUserInfoValidationError) 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 %sMediaUserInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaUserInfoValidationError{}

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

// Validate checks the field values on MediaUserListResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *MediaUserListResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaUserListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaUserListRespMultiError, or nil if none found.
func (m *MediaUserListResp) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaUserListResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, MediaUserListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, MediaUserListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MediaUserListRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return MediaUserListRespMultiError(errors)
	}

	return nil
}

// MediaUserListRespMultiError is an error wrapping multiple validation errors
// returned by MediaUserListResp.ValidateAll() if the designated constraints
// aren't met.
type MediaUserListRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaUserListRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaUserListRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaUserListRespValidationError) 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 %sMediaUserListResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaUserListRespValidationError{}

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

// Validate checks the field values on UpdateMediaAccountReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateMediaAccountReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateMediaAccountReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateMediaAccountReqMultiError, or nil if none found.
func (m *UpdateMediaAccountReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateMediaAccountReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PlatformID

	// no validation rules for PlatformUserName

	// no validation rules for PlatformUserID

	// no validation rules for ArtistUuid

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for MediaAccountUuid

	// no validation rules for ManagerUuid

	// no validation rules for ManagerUserName

	// no validation rules for ArtistPhoneAreaCode

	// no validation rules for ArtistSubNum

	if len(errors) > 0 {
		return UpdateMediaAccountReqMultiError(errors)
	}

	return nil
}

// UpdateMediaAccountReqMultiError is an error wrapping multiple validation
// errors returned by UpdateMediaAccountReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateMediaAccountReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateMediaAccountReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateMediaAccountReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateMediaAccountReqValidationError) 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 %sUpdateMediaAccountReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateMediaAccountReqValidationError{}

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

// Validate checks the field values on UpdateMediaAccountResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateMediaAccountResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateMediaAccountResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateMediaAccountRespMultiError, or nil if none found.
func (m *UpdateMediaAccountResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateMediaAccountResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for MediaAccountUuid

	if len(errors) > 0 {
		return UpdateMediaAccountRespMultiError(errors)
	}

	return nil
}

// UpdateMediaAccountRespMultiError is an error wrapping multiple validation
// errors returned by UpdateMediaAccountResp.ValidateAll() if the designated
// constraints aren't met.
type UpdateMediaAccountRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateMediaAccountRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateMediaAccountRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateMediaAccountRespValidationError) 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 %sUpdateMediaAccountResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateMediaAccountRespValidationError{}

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

// Validate checks the field values on UnbindManagerReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UnbindManagerReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UnbindManagerReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UnbindManagerReqMultiError, or nil if none found.
func (m *UnbindManagerReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UnbindManagerReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for MediaAccountUuid

	if len(errors) > 0 {
		return UnbindManagerReqMultiError(errors)
	}

	return nil
}

// UnbindManagerReqMultiError is an error wrapping multiple validation errors
// returned by UnbindManagerReq.ValidateAll() if the designated constraints
// aren't met.
type UnbindManagerReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UnbindManagerReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UnbindManagerReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UnbindManagerReqValidationError) 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 %sUnbindManagerReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UnbindManagerReqValidationError{}

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

// Validate checks the field values on UnbindManagerResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UnbindManagerResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UnbindManagerResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UnbindManagerRespMultiError, or nil if none found.
func (m *UnbindManagerResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UnbindManagerResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for OldBindArtistUuid

	if len(errors) > 0 {
		return UnbindManagerRespMultiError(errors)
	}

	return nil
}

// UnbindManagerRespMultiError is an error wrapping multiple validation errors
// returned by UnbindManagerResp.ValidateAll() if the designated constraints
// aren't met.
type UnbindManagerRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UnbindManagerRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UnbindManagerRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UnbindManagerRespValidationError) 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 %sUnbindManagerResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UnbindManagerRespValidationError{}

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

// Validate checks the field values on BindManagerReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *BindManagerReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on BindManagerReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in BindManagerReqMultiError,
// or nil if none found.
func (m *BindManagerReq) ValidateAll() error {
	return m.validate(true)
}

func (m *BindManagerReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for MediaAccountUuid

	// no validation rules for ManagerUuid

	// no validation rules for ManagerUserName

	if len(errors) > 0 {
		return BindManagerReqMultiError(errors)
	}

	return nil
}

// BindManagerReqMultiError is an error wrapping multiple validation errors
// returned by BindManagerReq.ValidateAll() if the designated constraints
// aren't met.
type BindManagerReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m BindManagerReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m BindManagerReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e BindManagerReqValidationError) 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 %sBindManagerReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = BindManagerReqValidationError{}

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

// Validate checks the field values on UpdateWorkImageReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkImageReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkImageReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkImageReqMultiError, or nil if none found.
func (m *UpdateWorkImageReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkImageReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Title

	// no validation rules for Content

	if all {
		switch v := interface{}(m.GetPublishConfig1()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig1",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig1",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig1()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkImageReqValidationError{
				field:  "PublishConfig1",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetPublishConfig2()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig2",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig2",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig2()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkImageReqValidationError{
				field:  "PublishConfig2",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetPublishConfig3()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig3",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig3",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig3()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkImageReqValidationError{
				field:  "PublishConfig3",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetPublishConfig4()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig4",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig4",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig4()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkImageReqValidationError{
				field:  "PublishConfig4",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for Action

	// no validation rules for WorkUuid

	// no validation rules for ArtistUuid

	// no validation rules for ArtistPhone

	// no validation rules for ArtistName

	// no validation rules for ArtistPhoneAreaCode

	// no validation rules for Source

	// no validation rules for LineNo

	// no validation rules for Remark

	// no validation rules for Success

	// no validation rules for ArtistSubNum

	// no validation rules for ScriptUuid

	if all {
		switch v := interface{}(m.GetPublishConfig5()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig5",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkImageReqValidationError{
					field:  "PublishConfig5",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig5()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkImageReqValidationError{
				field:  "PublishConfig5",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for From

	if len(errors) > 0 {
		return UpdateWorkImageReqMultiError(errors)
	}

	return nil
}

// UpdateWorkImageReqMultiError is an error wrapping multiple validation errors
// returned by UpdateWorkImageReq.ValidateAll() if the designated constraints
// aren't met.
type UpdateWorkImageReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkImageReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkImageReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateWorkImageReqValidationError) 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 %sUpdateWorkImageReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkImageReqValidationError{}

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

// Validate checks the field values on UpdateWorkImageResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkImageResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkImageResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkImageRespMultiError, or nil if none found.
func (m *UpdateWorkImageResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkImageResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	if len(errors) > 0 {
		return UpdateWorkImageRespMultiError(errors)
	}

	return nil
}

// UpdateWorkImageRespMultiError is an error wrapping multiple validation
// errors returned by UpdateWorkImageResp.ValidateAll() if the designated
// constraints aren't met.
type UpdateWorkImageRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkImageRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkImageRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateWorkImageRespValidationError) 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 %sUpdateWorkImageResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkImageRespValidationError{}

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

// Validate checks the field values on PublishConfig with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *PublishConfig) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PublishConfig with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in PublishConfigMultiError, or
// nil if none found.
func (m *PublishConfig) ValidateAll() error {
	return m.validate(true)
}

func (m *PublishConfig) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ForbidComment

	// no validation rules for PublicType

	// no validation rules for CanJoin

	// no validation rules for CanQuote

	// no validation rules for CanComment

	// no validation rules for IsAI

	if len(errors) > 0 {
		return PublishConfigMultiError(errors)
	}

	return nil
}

// PublishConfigMultiError is an error wrapping multiple validation errors
// returned by PublishConfig.ValidateAll() if the designated constraints
// aren't met.
type PublishConfigMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m PublishConfigMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m PublishConfigMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e PublishConfigValidationError) 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 %sPublishConfig.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PublishConfigValidationError{}

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

// Validate checks the field values on UpdateWorkVideoReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkVideoReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkVideoReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkVideoReqMultiError, or nil if none found.
func (m *UpdateWorkVideoReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkVideoReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Title

	// no validation rules for Content

	// no validation rules for VideoUrl

	// no validation rules for CoverUrl

	if all {
		switch v := interface{}(m.GetPublishConfig1()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig1",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig1",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig1()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkVideoReqValidationError{
				field:  "PublishConfig1",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetPublishConfig2()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig2",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig2",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig2()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkVideoReqValidationError{
				field:  "PublishConfig2",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetPublishConfig3()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig3",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig3",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig3()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkVideoReqValidationError{
				field:  "PublishConfig3",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetPublishConfig4()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig4",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig4",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig4()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkVideoReqValidationError{
				field:  "PublishConfig4",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for Action

	// no validation rules for WorkUuid

	// no validation rules for ArtistUuid

	// no validation rules for ArtistPhone

	// no validation rules for ArtistName

	// no validation rules for ArtistPhoneAreaCode

	// no validation rules for Source

	// no validation rules for CoverTimestampMs

	// no validation rules for AutoPublish

	// no validation rules for ScriptUuid

	// no validation rules for ArtistSubNum

	if all {
		switch v := interface{}(m.GetPublishConfig5()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig5",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateWorkVideoReqValidationError{
					field:  "PublishConfig5",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig5()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateWorkVideoReqValidationError{
				field:  "PublishConfig5",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if len(errors) > 0 {
		return UpdateWorkVideoReqMultiError(errors)
	}

	return nil
}

// UpdateWorkVideoReqMultiError is an error wrapping multiple validation errors
// returned by UpdateWorkVideoReq.ValidateAll() if the designated constraints
// aren't met.
type UpdateWorkVideoReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkVideoReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkVideoReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateWorkVideoReqValidationError) 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 %sUpdateWorkVideoReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkVideoReqValidationError{}

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

// Validate checks the field values on UpdateWorkVideoResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkVideoResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkVideoResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkVideoRespMultiError, or nil if none found.
func (m *UpdateWorkVideoResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkVideoResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	if len(errors) > 0 {
		return UpdateWorkVideoRespMultiError(errors)
	}

	return nil
}

// UpdateWorkVideoRespMultiError is an error wrapping multiple validation
// errors returned by UpdateWorkVideoResp.ValidateAll() if the designated
// constraints aren't met.
type UpdateWorkVideoRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkVideoRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkVideoRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateWorkVideoRespValidationError) 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 %sUpdateWorkVideoResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkVideoRespValidationError{}

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

// Validate checks the field values on MediaInfoReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *MediaInfoReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaInfoReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in MediaInfoReqMultiError, or
// nil if none found.
func (m *MediaInfoReq) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaInfoReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for PlatformID

	// no validation rules for PlatformUserName

	if len(errors) > 0 {
		return MediaInfoReqMultiError(errors)
	}

	return nil
}

// MediaInfoReqMultiError is an error wrapping multiple validation errors
// returned by MediaInfoReq.ValidateAll() if the designated constraints aren't met.
type MediaInfoReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaInfoReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaInfoReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaInfoReqValidationError) 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 %sMediaInfoReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaInfoReqValidationError{}

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

// Validate checks the field values on MediaInfoResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *MediaInfoResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaInfoResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in MediaInfoRespMultiError, or
// nil if none found.
func (m *MediaInfoResp) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaInfoResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if all {
		switch v := interface{}(m.GetInfo()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, MediaInfoRespValidationError{
					field:  "Info",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, MediaInfoRespValidationError{
					field:  "Info",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetInfo()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return MediaInfoRespValidationError{
				field:  "Info",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if len(errors) > 0 {
		return MediaInfoRespMultiError(errors)
	}

	return nil
}

// MediaInfoRespMultiError is an error wrapping multiple validation errors
// returned by MediaInfoResp.ValidateAll() if the designated constraints
// aren't met.
type MediaInfoRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaInfoRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaInfoRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaInfoRespValidationError) 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 %sMediaInfoResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaInfoRespValidationError{}

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

// Validate checks the field values on MediaInfoByPlatformReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *MediaInfoByPlatformReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaInfoByPlatformReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaInfoByPlatformReqMultiError, or nil if none found.
func (m *MediaInfoByPlatformReq) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaInfoByPlatformReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for PlatformID

	if len(errors) > 0 {
		return MediaInfoByPlatformReqMultiError(errors)
	}

	return nil
}

// MediaInfoByPlatformReqMultiError is an error wrapping multiple validation
// errors returned by MediaInfoByPlatformReq.ValidateAll() if the designated
// constraints aren't met.
type MediaInfoByPlatformReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaInfoByPlatformReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaInfoByPlatformReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaInfoByPlatformReqValidationError) 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 %sMediaInfoByPlatformReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaInfoByPlatformReqValidationError{}

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

// Validate checks the field values on MediaInfoByPlatformResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *MediaInfoByPlatformResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaInfoByPlatformResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaInfoByPlatformRespMultiError, or nil if none found.
func (m *MediaInfoByPlatformResp) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaInfoByPlatformResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if all {
		switch v := interface{}(m.GetInfo()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, MediaInfoByPlatformRespValidationError{
					field:  "Info",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, MediaInfoByPlatformRespValidationError{
					field:  "Info",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetInfo()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return MediaInfoByPlatformRespValidationError{
				field:  "Info",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if len(errors) > 0 {
		return MediaInfoByPlatformRespMultiError(errors)
	}

	return nil
}

// MediaInfoByPlatformRespMultiError is an error wrapping multiple validation
// errors returned by MediaInfoByPlatformResp.ValidateAll() if the designated
// constraints aren't met.
type MediaInfoByPlatformRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaInfoByPlatformRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaInfoByPlatformRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaInfoByPlatformRespValidationError) 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 %sMediaInfoByPlatformResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaInfoByPlatformRespValidationError{}

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

// Validate checks the field values on WorkListReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *WorkListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkListReq with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in WorkListReqMultiError, or
// nil if none found.
func (m *WorkListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistVal

	// no validation rules for PlatformID

	// no validation rules for WorkCategory

	// no validation rules for SubmitStartTime

	// no validation rules for SubmitEndTime

	// no validation rules for StatusUpdateTimeStart

	// no validation rules for StatusUpdateTimeEnd

	// no validation rules for Title

	// no validation rules for WorkStatus

	// no validation rules for MediaAccountUuid

	// no validation rules for ManagerUserVal

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for CostType

	// no validation rules for ScriptUuid

	// no validation rules for ArtistSubNum

	// no validation rules for TiktokStatus

	// no validation rules for InsStatus

	// no validation rules for DmStatus

	// no validation rules for StartTime1

	// no validation rules for EndTime1

	// no validation rules for StartTime4

	// no validation rules for EndTime4

	// no validation rules for StartTime9

	// no validation rules for EndTime9

	// no validation rules for StartTime6

	// no validation rules for EndTime6

	// no validation rules for NeedPublishMediaID

	// no validation rules for YoutubeStatus

	// no validation rules for BlueskyStatus

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return WorkListReqMultiError(errors)
	}

	return nil
}

// WorkListReqMultiError is an error wrapping multiple validation errors
// returned by WorkListReq.ValidateAll() if the designated constraints aren't met.
type WorkListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkListReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkListReqValidationError) 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 %sWorkListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkListReqValidationError{}

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

// Validate checks the field values on WorkListResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *WorkListResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkListResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in WorkListRespMultiError, or
// nil if none found.
func (m *WorkListResp) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkListResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, WorkListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, WorkListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return WorkListRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return WorkListRespMultiError(errors)
	}

	return nil
}

// WorkListRespMultiError is an error wrapping multiple validation errors
// returned by WorkListResp.ValidateAll() if the designated constraints aren't met.
type WorkListRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkListRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkListRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkListRespValidationError) 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 %sWorkListResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkListRespValidationError{}

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

// Validate checks the field values on WorkDetailReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *WorkDetailReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkDetailReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in WorkDetailReqMultiError, or
// nil if none found.
func (m *WorkDetailReq) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkDetailReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	if len(errors) > 0 {
		return WorkDetailReqMultiError(errors)
	}

	return nil
}

// WorkDetailReqMultiError is an error wrapping multiple validation errors
// returned by WorkDetailReq.ValidateAll() if the designated constraints
// aren't met.
type WorkDetailReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkDetailReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkDetailReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkDetailReqValidationError) 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 %sWorkDetailReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkDetailReqValidationError{}

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

// Validate checks the field values on WorkLogInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *WorkLogInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkLogInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in WorkLogInfoMultiError, or
// nil if none found.
func (m *WorkLogInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkLogInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for Title

	// no validation rules for Content

	// no validation rules for OperatorName

	// no validation rules for OperatorID

	// no validation rules for UpdateTime

	// no validation rules for ExtraData

	// no validation rules for WorkStatus

	if len(errors) > 0 {
		return WorkLogInfoMultiError(errors)
	}

	return nil
}

// WorkLogInfoMultiError is an error wrapping multiple validation errors
// returned by WorkLogInfo.ValidateAll() if the designated constraints aren't met.
type WorkLogInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkLogInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkLogInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkLogInfoValidationError) 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 %sWorkLogInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkLogInfoValidationError{}

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

// Validate checks the field values on WorkDetailResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *WorkDetailResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkDetailResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in WorkDetailRespMultiError,
// or nil if none found.
func (m *WorkDetailResp) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkDetailResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for Title

	// no validation rules for Content

	// no validation rules for WorkStatus

	if all {
		switch v := interface{}(m.GetPublishConfig1()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig1",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig1",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig1()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return WorkDetailRespValidationError{
				field:  "PublishConfig1",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetPublishConfig2()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig2",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig2",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig2()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return WorkDetailRespValidationError{
				field:  "PublishConfig2",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetPublishConfig3()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig3",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig3",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig3()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return WorkDetailRespValidationError{
				field:  "PublishConfig3",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetPublishConfig4()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig4",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig4",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig4()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return WorkDetailRespValidationError{
				field:  "PublishConfig4",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for VideoUrl

	// no validation rules for CoverUrl

	// no validation rules for ApprovalID

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, WorkDetailRespValidationError{
						field:  fmt.Sprintf("WorkLogData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, WorkDetailRespValidationError{
						field:  fmt.Sprintf("WorkLogData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return WorkDetailRespValidationError{
					field:  fmt.Sprintf("WorkLogData[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for WorkCategory

	{
		sorted_keys := make([]string, len(m.GetMediaAccData()))
		i := 0
		for key := range m.GetMediaAccData() {
			sorted_keys[i] = key
			i++
		}
		sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] })
		for _, key := range sorted_keys {
			val := m.GetMediaAccData()[key]
			_ = val

			// no validation rules for MediaAccData[key]

			if all {
				switch v := interface{}(val).(type) {
				case interface{ ValidateAll() error }:
					if err := v.ValidateAll(); err != nil {
						errors = append(errors, WorkDetailRespValidationError{
							field:  fmt.Sprintf("MediaAccData[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				case interface{ Validate() error }:
					if err := v.Validate(); err != nil {
						errors = append(errors, WorkDetailRespValidationError{
							field:  fmt.Sprintf("MediaAccData[%v]", key),
							reason: "embedded message failed validation",
							cause:  err,
						})
					}
				}
			} else if v, ok := interface{}(val).(interface{ Validate() error }); ok {
				if err := v.Validate(); err != nil {
					return WorkDetailRespValidationError{
						field:  fmt.Sprintf("MediaAccData[%v]", key),
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		}
	}

	// no validation rules for CoverTimestampMs

	// no validation rules for ScriptUuid

	// no validation rules for ArtistUuid

	// no validation rules for ArtistSubNum

	// no validation rules for ScriptInfo

	if all {
		switch v := interface{}(m.GetPublishConfig5()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig5",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, WorkDetailRespValidationError{
					field:  "PublishConfig5",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetPublishConfig5()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return WorkDetailRespValidationError{
				field:  "PublishConfig5",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for BundleOrderUuid

	if len(errors) > 0 {
		return WorkDetailRespMultiError(errors)
	}

	return nil
}

// WorkDetailRespMultiError is an error wrapping multiple validation errors
// returned by WorkDetailResp.ValidateAll() if the designated constraints
// aren't met.
type WorkDetailRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkDetailRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkDetailRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkDetailRespValidationError) 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 %sWorkDetailResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkDetailRespValidationError{}

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

// Validate checks the field values on UpdateStatusReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UpdateStatusReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateStatusReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateStatusReqMultiError, or nil if none found.
func (m *UpdateStatusReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateStatusReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkAction

	// no validation rules for WorkUuid

	// no validation rules for ApprovalID

	// no validation rules for ConfirmRemark

	// no validation rules for ConfirmStatus

	// no validation rules for ApprovalReply

	// no validation rules for AutoPublish

	// no validation rules for CostType

	// no validation rules for ConfirmFailType

	// no validation rules for ApprovalTime

	if len(errors) > 0 {
		return UpdateStatusReqMultiError(errors)
	}

	return nil
}

// UpdateStatusReqMultiError is an error wrapping multiple validation errors
// returned by UpdateStatusReq.ValidateAll() if the designated constraints
// aren't met.
type UpdateStatusReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateStatusReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateStatusReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateStatusReqValidationError) 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 %sUpdateStatusReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateStatusReqValidationError{}

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

// Validate checks the field values on MediaAccountsReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *MediaAccountsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaAccountsReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaAccountsReqMultiError, or nil if none found.
func (m *MediaAccountsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaAccountsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return MediaAccountsReqMultiError(errors)
	}

	return nil
}

// MediaAccountsReqMultiError is an error wrapping multiple validation errors
// returned by MediaAccountsReq.ValidateAll() if the designated constraints
// aren't met.
type MediaAccountsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaAccountsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaAccountsReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaAccountsReqValidationError) 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 %sMediaAccountsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaAccountsReqValidationError{}

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

// Validate checks the field values on MediaAccountsResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *MediaAccountsResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaAccountsResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaAccountsRespMultiError, or nil if none found.
func (m *MediaAccountsResp) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaAccountsResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, MediaAccountsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, MediaAccountsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MediaAccountsRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return MediaAccountsRespMultiError(errors)
	}

	return nil
}

// MediaAccountsRespMultiError is an error wrapping multiple validation errors
// returned by MediaAccountsResp.ValidateAll() if the designated constraints
// aren't met.
type MediaAccountsRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaAccountsRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaAccountsRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaAccountsRespValidationError) 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 %sMediaAccountsResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaAccountsRespValidationError{}

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

// Validate checks the field values on MediaWorksReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *MediaWorksReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaWorksReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in MediaWorksReqMultiError, or
// nil if none found.
func (m *MediaWorksReq) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaWorksReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for MediaAccountUuid

	// no validation rules for Page

	// no validation rules for PageSize

	if len(errors) > 0 {
		return MediaWorksReqMultiError(errors)
	}

	return nil
}

// MediaWorksReqMultiError is an error wrapping multiple validation errors
// returned by MediaWorksReq.ValidateAll() if the designated constraints
// aren't met.
type MediaWorksReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaWorksReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaWorksReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaWorksReqValidationError) 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 %sMediaWorksReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaWorksReqValidationError{}

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

// Validate checks the field values on MediaWorksResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *MediaWorksResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaWorksResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in MediaWorksRespMultiError,
// or nil if none found.
func (m *MediaWorksResp) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaWorksResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Count

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, MediaWorksRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, MediaWorksRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MediaWorksRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return MediaWorksRespMultiError(errors)
	}

	return nil
}

// MediaWorksRespMultiError is an error wrapping multiple validation errors
// returned by MediaWorksResp.ValidateAll() if the designated constraints
// aren't met.
type MediaWorksRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaWorksRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaWorksRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e MediaWorksRespValidationError) 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 %sMediaWorksResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaWorksRespValidationError{}

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

// Validate checks the field values on PublishReq with the rules defined in the
// proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *PublishReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PublishReq with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in PublishReqMultiError, or
// nil if none found.
func (m *PublishReq) ValidateAll() error {
	return m.validate(true)
}

func (m *PublishReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PublishSource

	if len(errors) > 0 {
		return PublishReqMultiError(errors)
	}

	return nil
}

// PublishReqMultiError is an error wrapping multiple validation errors
// returned by PublishReq.ValidateAll() if the designated constraints aren't met.
type PublishReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m PublishReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m PublishReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e PublishReqValidationError) 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 %sPublishReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PublishReqValidationError{}

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

// Validate checks the field values on PublishResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *PublishResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PublishResp with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in PublishRespMultiError, or
// nil if none found.
func (m *PublishResp) ValidateAll() error {
	return m.validate(true)
}

func (m *PublishResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, PublishRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, PublishRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return PublishRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return PublishRespMultiError(errors)
	}

	return nil
}

// PublishRespMultiError is an error wrapping multiple validation errors
// returned by PublishResp.ValidateAll() if the designated constraints aren't met.
type PublishRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m PublishRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m PublishRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e PublishRespValidationError) 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 %sPublishResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PublishRespValidationError{}

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

// Validate checks the field values on RePublishReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *RePublishReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RePublishReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in RePublishReqMultiError, or
// nil if none found.
func (m *RePublishReq) ValidateAll() error {
	return m.validate(true)
}

func (m *RePublishReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PublishSource

	if len(errors) > 0 {
		return RePublishReqMultiError(errors)
	}

	return nil
}

// RePublishReqMultiError is an error wrapping multiple validation errors
// returned by RePublishReq.ValidateAll() if the designated constraints aren't met.
type RePublishReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m RePublishReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m RePublishReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e RePublishReqValidationError) 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 %sRePublishReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RePublishReqValidationError{}

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

// Validate checks the field values on RePublishResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *RePublishResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RePublishResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in RePublishRespMultiError, or
// nil if none found.
func (m *RePublishResp) ValidateAll() error {
	return m.validate(true)
}

func (m *RePublishResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return RePublishRespMultiError(errors)
	}

	return nil
}

// RePublishRespMultiError is an error wrapping multiple validation errors
// returned by RePublishResp.ValidateAll() if the designated constraints
// aren't met.
type RePublishRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m RePublishRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m RePublishRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e RePublishRespValidationError) 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 %sRePublishResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RePublishRespValidationError{}

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

// Validate checks the field values on DelWorkReq with the rules defined in the
// proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *DelWorkReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DelWorkReq with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in DelWorkReqMultiError, or
// nil if none found.
func (m *DelWorkReq) ValidateAll() error {
	return m.validate(true)
}

func (m *DelWorkReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	if len(errors) > 0 {
		return DelWorkReqMultiError(errors)
	}

	return nil
}

// DelWorkReqMultiError is an error wrapping multiple validation errors
// returned by DelWorkReq.ValidateAll() if the designated constraints aren't met.
type DelWorkReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m DelWorkReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m DelWorkReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e DelWorkReqValidationError) 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 %sDelWorkReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DelWorkReqValidationError{}

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

// Validate checks the field values on WorkInfoReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *WorkInfoReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkInfoReq with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in WorkInfoReqMultiError, or
// nil if none found.
func (m *WorkInfoReq) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkInfoReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	if len(errors) > 0 {
		return WorkInfoReqMultiError(errors)
	}

	return nil
}

// WorkInfoReqMultiError is an error wrapping multiple validation errors
// returned by WorkInfoReq.ValidateAll() if the designated constraints aren't met.
type WorkInfoReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkInfoReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkInfoReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkInfoReqValidationError) 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 %sWorkInfoReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkInfoReqValidationError{}

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

// Validate checks the field values on WorkInfoResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *WorkInfoResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkInfoResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in WorkInfoRespMultiError, or
// nil if none found.
func (m *WorkInfoResp) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkInfoResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkStatus

	// no validation rules for ArtistUuid

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for ArtistPhoneAreaCode

	// no validation rules for WorkCategory

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, WorkInfoRespValidationError{
						field:  fmt.Sprintf("PlatformInfoData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, WorkInfoRespValidationError{
						field:  fmt.Sprintf("PlatformInfoData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return WorkInfoRespValidationError{
					field:  fmt.Sprintf("PlatformInfoData[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Title

	// no validation rules for PublishStatus

	// no validation rules for BundleOrderUuid

	if len(errors) > 0 {
		return WorkInfoRespMultiError(errors)
	}

	return nil
}

// WorkInfoRespMultiError is an error wrapping multiple validation errors
// returned by WorkInfoResp.ValidateAll() if the designated constraints aren't met.
type WorkInfoRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkInfoRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkInfoRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkInfoRespValidationError) 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 %sWorkInfoResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkInfoRespValidationError{}

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

// Validate checks the field values on WorkListPublishedReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkListPublishedReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkListPublishedReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkListPublishedReqMultiError, or nil if none found.
func (m *WorkListPublishedReq) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkListPublishedReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for SortBy

	// no validation rules for SortType

	if len(errors) > 0 {
		return WorkListPublishedReqMultiError(errors)
	}

	return nil
}

// WorkListPublishedReqMultiError is an error wrapping multiple validation
// errors returned by WorkListPublishedReq.ValidateAll() if the designated
// constraints aren't met.
type WorkListPublishedReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkListPublishedReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkListPublishedReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkListPublishedReqValidationError) 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 %sWorkListPublishedReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkListPublishedReqValidationError{}

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

// Validate checks the field values on WorkListPublishedResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkListPublishedResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkListPublishedResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkListPublishedRespMultiError, or nil if none found.
func (m *WorkListPublishedResp) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkListPublishedResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Count

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, WorkListPublishedRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, WorkListPublishedRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return WorkListPublishedRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return WorkListPublishedRespMultiError(errors)
	}

	return nil
}

// WorkListPublishedRespMultiError is an error wrapping multiple validation
// errors returned by WorkListPublishedResp.ValidateAll() if the designated
// constraints aren't met.
type WorkListPublishedRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkListPublishedRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkListPublishedRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkListPublishedRespValidationError) 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 %sWorkListPublishedResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkListPublishedRespValidationError{}

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

// Validate checks the field values on ArtistInfoReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *ArtistInfoReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistInfoReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in ArtistInfoReqMultiError, or
// nil if none found.
func (m *ArtistInfoReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistInfoReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return ArtistInfoReqMultiError(errors)
	}

	return nil
}

// ArtistInfoReqMultiError is an error wrapping multiple validation errors
// returned by ArtistInfoReq.ValidateAll() if the designated constraints
// aren't met.
type ArtistInfoReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistInfoReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistInfoReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ArtistInfoReqValidationError) 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 %sArtistInfoReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistInfoReqValidationError{}

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

// Validate checks the field values on ArtistInfoResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *ArtistInfoResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistInfoResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in ArtistInfoRespMultiError,
// or nil if none found.
func (m *ArtistInfoResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistInfoResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for TikTokEffectiveCount

	// no validation rules for YouTubeEffectiveCount

	// no validation rules for InsEffectiveCount

	// no validation rules for DMEffectiveCount

	// no validation rules for ProfileKey

	// no validation rules for SubNum

	// no validation rules for BlueskyEffectiveCount

	if len(errors) > 0 {
		return ArtistInfoRespMultiError(errors)
	}

	return nil
}

// ArtistInfoRespMultiError is an error wrapping multiple validation errors
// returned by ArtistInfoResp.ValidateAll() if the designated constraints
// aren't met.
type ArtistInfoRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistInfoRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistInfoRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ArtistInfoRespValidationError) 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 %sArtistInfoResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistInfoRespValidationError{}

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

// Validate checks the field values on ImportWorkBatchReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ImportWorkBatchReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ImportWorkBatchReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ImportWorkBatchReqMultiError, or nil if none found.
func (m *ImportWorkBatchReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ImportWorkBatchReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ImportWorkBatchReqValidationError{
						field:  fmt.Sprintf("ImageWorks[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ImportWorkBatchReqValidationError{
						field:  fmt.Sprintf("ImageWorks[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ImportWorkBatchReqValidationError{
					field:  fmt.Sprintf("ImageWorks[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return ImportWorkBatchReqMultiError(errors)
	}

	return nil
}

// ImportWorkBatchReqMultiError is an error wrapping multiple validation errors
// returned by ImportWorkBatchReq.ValidateAll() if the designated constraints
// aren't met.
type ImportWorkBatchReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ImportWorkBatchReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ImportWorkBatchReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ImportWorkBatchReqValidationError) 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 %sImportWorkBatchReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ImportWorkBatchReqValidationError{}

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

// Validate checks the field values on ImportWorkBatchResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ImportWorkBatchResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ImportWorkBatchResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ImportWorkBatchRespMultiError, or nil if none found.
func (m *ImportWorkBatchResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ImportWorkBatchResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ImportWorkBatchRespValidationError{
						field:  fmt.Sprintf("ImageWorks[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ImportWorkBatchRespValidationError{
						field:  fmt.Sprintf("ImageWorks[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ImportWorkBatchRespValidationError{
					field:  fmt.Sprintf("ImageWorks[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for SuccessCount

	// no validation rules for FailCount

	if len(errors) > 0 {
		return ImportWorkBatchRespMultiError(errors)
	}

	return nil
}

// ImportWorkBatchRespMultiError is an error wrapping multiple validation
// errors returned by ImportWorkBatchResp.ValidateAll() if the designated
// constraints aren't met.
type ImportWorkBatchRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ImportWorkBatchRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ImportWorkBatchRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ImportWorkBatchRespValidationError) 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 %sImportWorkBatchResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ImportWorkBatchRespValidationError{}

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

// Validate checks the field values on PlatformInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *PlatformInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PlatformInfo with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in PlatformInfoMultiError, or
// nil if none found.
func (m *PlatformInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *PlatformInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for MediaAccountUuid

	// no validation rules for PlatformID

	// no validation rules for PublishType

	// no validation rules for PublishResp

	// no validation rules for PublishMediaId

	// no validation rules for PublishMediaStatus

	// no validation rules for Remark

	// no validation rules for PlatformUuid

	// no validation rules for PublishSource

	if len(errors) > 0 {
		return PlatformInfoMultiError(errors)
	}

	return nil
}

// PlatformInfoMultiError is an error wrapping multiple validation errors
// returned by PlatformInfo.ValidateAll() if the designated constraints aren't met.
type PlatformInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m PlatformInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m PlatformInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e PlatformInfoValidationError) 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 %sPlatformInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PlatformInfoValidationError{}

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

// Validate checks the field values on UpdateWorkPlatformInfoReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkPlatformInfoReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkPlatformInfoReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkPlatformInfoReqMultiError, or nil if none found.
func (m *UpdateWorkPlatformInfoReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkPlatformInfoReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpdateWorkPlatformInfoReqValidationError{
						field:  fmt.Sprintf("PlatformInfoData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpdateWorkPlatformInfoReqValidationError{
						field:  fmt.Sprintf("PlatformInfoData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpdateWorkPlatformInfoReqValidationError{
					field:  fmt.Sprintf("PlatformInfoData[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return UpdateWorkPlatformInfoReqMultiError(errors)
	}

	return nil
}

// UpdateWorkPlatformInfoReqMultiError is an error wrapping multiple validation
// errors returned by UpdateWorkPlatformInfoReq.ValidateAll() if the
// designated constraints aren't met.
type UpdateWorkPlatformInfoReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkPlatformInfoReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkPlatformInfoReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateWorkPlatformInfoReqValidationError) 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 %sUpdateWorkPlatformInfoReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkPlatformInfoReqValidationError{}

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

// Validate checks the field values on UpdateWorkPlatformInfoResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkPlatformInfoResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkPlatformInfoResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkPlatformInfoRespMultiError, or nil if none found.
func (m *UpdateWorkPlatformInfoResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkPlatformInfoResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if len(errors) > 0 {
		return UpdateWorkPlatformInfoRespMultiError(errors)
	}

	return nil
}

// UpdateWorkPlatformInfoRespMultiError is an error wrapping multiple
// validation errors returned by UpdateWorkPlatformInfoResp.ValidateAll() if
// the designated constraints aren't met.
type UpdateWorkPlatformInfoRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkPlatformInfoRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkPlatformInfoRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateWorkPlatformInfoRespValidationError) 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 %sUpdateWorkPlatformInfoResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkPlatformInfoRespValidationError{}

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

// Validate checks the field values on UpdateWorkPublishLogReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkPublishLogReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkPublishLogReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkPublishLogReqMultiError, or nil if none found.
func (m *UpdateWorkPublishLogReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkPublishLogReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for PlatformID

	// no validation rules for Detail

	// no validation rules for Action

	// no validation rules for PublishSource

	// no validation rules for PublishMediaID

	// no validation rules for PublishMediaStatus

	if len(errors) > 0 {
		return UpdateWorkPublishLogReqMultiError(errors)
	}

	return nil
}

// UpdateWorkPublishLogReqMultiError is an error wrapping multiple validation
// errors returned by UpdateWorkPublishLogReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateWorkPublishLogReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkPublishLogReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkPublishLogReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateWorkPublishLogReqValidationError) 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 %sUpdateWorkPublishLogReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkPublishLogReqValidationError{}

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

// Validate checks the field values on RefreshWorkListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *RefreshWorkListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RefreshWorkListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// RefreshWorkListReqMultiError, or nil if none found.
func (m *RefreshWorkListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *RefreshWorkListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PublishStatus

	if len(errors) > 0 {
		return RefreshWorkListReqMultiError(errors)
	}

	return nil
}

// RefreshWorkListReqMultiError is an error wrapping multiple validation errors
// returned by RefreshWorkListReq.ValidateAll() if the designated constraints
// aren't met.
type RefreshWorkListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m RefreshWorkListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m RefreshWorkListReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e RefreshWorkListReqValidationError) 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 %sRefreshWorkListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RefreshWorkListReqValidationError{}

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

// Validate checks the field values on RefreshWorkListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *RefreshWorkListResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RefreshWorkListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// RefreshWorkListRespMultiError, or nil if none found.
func (m *RefreshWorkListResp) ValidateAll() error {
	return m.validate(true)
}

func (m *RefreshWorkListResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, RefreshWorkListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, RefreshWorkListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return RefreshWorkListRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return RefreshWorkListRespMultiError(errors)
	}

	return nil
}

// RefreshWorkListRespMultiError is an error wrapping multiple validation
// errors returned by RefreshWorkListResp.ValidateAll() if the designated
// constraints aren't met.
type RefreshWorkListRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m RefreshWorkListRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m RefreshWorkListRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e RefreshWorkListRespValidationError) 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 %sRefreshWorkListResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RefreshWorkListRespValidationError{}

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

// Validate checks the field values on OAuthAccountReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *OAuthAccountReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on OAuthAccountReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// OAuthAccountReqMultiError, or nil if none found.
func (m *OAuthAccountReq) ValidateAll() error {
	return m.validate(true)
}

func (m *OAuthAccountReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for MediaAccountUuid

	if len(errors) > 0 {
		return OAuthAccountReqMultiError(errors)
	}

	return nil
}

// OAuthAccountReqMultiError is an error wrapping multiple validation errors
// returned by OAuthAccountReq.ValidateAll() if the designated constraints
// aren't met.
type OAuthAccountReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m OAuthAccountReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m OAuthAccountReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e OAuthAccountReqValidationError) 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 %sOAuthAccountReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OAuthAccountReqValidationError{}

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

// Validate checks the field values on OAuthAccountResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *OAuthAccountResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on OAuthAccountResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// OAuthAccountRespMultiError, or nil if none found.
func (m *OAuthAccountResp) ValidateAll() error {
	return m.validate(true)
}

func (m *OAuthAccountResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Url

	if len(errors) > 0 {
		return OAuthAccountRespMultiError(errors)
	}

	return nil
}

// OAuthAccountRespMultiError is an error wrapping multiple validation errors
// returned by OAuthAccountResp.ValidateAll() if the designated constraints
// aren't met.
type OAuthAccountRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m OAuthAccountRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m OAuthAccountRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e OAuthAccountRespValidationError) 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 %sOAuthAccountResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OAuthAccountRespValidationError{}

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

// Validate checks the field values on OAuthAccountV2Req with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *OAuthAccountV2Req) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on OAuthAccountV2Req with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// OAuthAccountV2ReqMultiError, or nil if none found.
func (m *OAuthAccountV2Req) ValidateAll() error {
	return m.validate(true)
}

func (m *OAuthAccountV2Req) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for MediaAccountUuid

	if len(errors) > 0 {
		return OAuthAccountV2ReqMultiError(errors)
	}

	return nil
}

// OAuthAccountV2ReqMultiError is an error wrapping multiple validation errors
// returned by OAuthAccountV2Req.ValidateAll() if the designated constraints
// aren't met.
type OAuthAccountV2ReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m OAuthAccountV2ReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m OAuthAccountV2ReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e OAuthAccountV2ReqValidationError) 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 %sOAuthAccountV2Req.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OAuthAccountV2ReqValidationError{}

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

// Validate checks the field values on OAuthAccountV2Resp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *OAuthAccountV2Resp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on OAuthAccountV2Resp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// OAuthAccountV2RespMultiError, or nil if none found.
func (m *OAuthAccountV2Resp) ValidateAll() error {
	return m.validate(true)
}

func (m *OAuthAccountV2Resp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for ProfileKey

	// no validation rules for PlatformID

	// no validation rules for AuthUrl

	if len(errors) > 0 {
		return OAuthAccountV2RespMultiError(errors)
	}

	return nil
}

// OAuthAccountV2RespMultiError is an error wrapping multiple validation errors
// returned by OAuthAccountV2Resp.ValidateAll() if the designated constraints
// aren't met.
type OAuthAccountV2RespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m OAuthAccountV2RespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m OAuthAccountV2RespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e OAuthAccountV2RespValidationError) 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 %sOAuthAccountV2Resp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OAuthAccountV2RespValidationError{}

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

// Validate checks the field values on OAuthYoutubeTokenReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *OAuthYoutubeTokenReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on OAuthYoutubeTokenReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// OAuthYoutubeTokenReqMultiError, or nil if none found.
func (m *OAuthYoutubeTokenReq) ValidateAll() error {
	return m.validate(true)
}

func (m *OAuthYoutubeTokenReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for MediaAccountUuid

	// no validation rules for Code

	if len(errors) > 0 {
		return OAuthYoutubeTokenReqMultiError(errors)
	}

	return nil
}

// OAuthYoutubeTokenReqMultiError is an error wrapping multiple validation
// errors returned by OAuthYoutubeTokenReq.ValidateAll() if the designated
// constraints aren't met.
type OAuthYoutubeTokenReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m OAuthYoutubeTokenReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m OAuthYoutubeTokenReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e OAuthYoutubeTokenReqValidationError) 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 %sOAuthYoutubeTokenReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OAuthYoutubeTokenReqValidationError{}

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

// Validate checks the field values on OAuthYoutubeTokenResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *OAuthYoutubeTokenResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on OAuthYoutubeTokenResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// OAuthYoutubeTokenRespMultiError, or nil if none found.
func (m *OAuthYoutubeTokenResp) ValidateAll() error {
	return m.validate(true)
}

func (m *OAuthYoutubeTokenResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for AccessToken

	// no validation rules for RefreshToken

	// no validation rules for ExpireTime

	if len(errors) > 0 {
		return OAuthYoutubeTokenRespMultiError(errors)
	}

	return nil
}

// OAuthYoutubeTokenRespMultiError is an error wrapping multiple validation
// errors returned by OAuthYoutubeTokenResp.ValidateAll() if the designated
// constraints aren't met.
type OAuthYoutubeTokenRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m OAuthYoutubeTokenRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m OAuthYoutubeTokenRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e OAuthYoutubeTokenRespValidationError) 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 %sOAuthYoutubeTokenResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OAuthYoutubeTokenRespValidationError{}

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

// Validate checks the field values on OAuthCodeToTokenReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *OAuthCodeToTokenReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on OAuthCodeToTokenReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// OAuthCodeToTokenReqMultiError, or nil if none found.
func (m *OAuthCodeToTokenReq) ValidateAll() error {
	return m.validate(true)
}

func (m *OAuthCodeToTokenReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Code

	// no validation rules for UserID

	// no validation rules for PlatformID

	// no validation rules for State

	if len(errors) > 0 {
		return OAuthCodeToTokenReqMultiError(errors)
	}

	return nil
}

// OAuthCodeToTokenReqMultiError is an error wrapping multiple validation
// errors returned by OAuthCodeToTokenReq.ValidateAll() if the designated
// constraints aren't met.
type OAuthCodeToTokenReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m OAuthCodeToTokenReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m OAuthCodeToTokenReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e OAuthCodeToTokenReqValidationError) 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 %sOAuthCodeToTokenReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OAuthCodeToTokenReqValidationError{}

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

// Validate checks the field values on OAuthCodeToTokenResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *OAuthCodeToTokenResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on OAuthCodeToTokenResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// OAuthCodeToTokenRespMultiError, or nil if none found.
func (m *OAuthCodeToTokenResp) ValidateAll() error {
	return m.validate(true)
}

func (m *OAuthCodeToTokenResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if len(errors) > 0 {
		return OAuthCodeToTokenRespMultiError(errors)
	}

	return nil
}

// OAuthCodeToTokenRespMultiError is an error wrapping multiple validation
// errors returned by OAuthCodeToTokenResp.ValidateAll() if the designated
// constraints aren't met.
type OAuthCodeToTokenRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m OAuthCodeToTokenRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m OAuthCodeToTokenRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e OAuthCodeToTokenRespValidationError) 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 %sOAuthCodeToTokenResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OAuthCodeToTokenRespValidationError{}

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

// Validate checks the field values on UpdateOAuthReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *UpdateOAuthReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateOAuthReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in UpdateOAuthReqMultiError,
// or nil if none found.
func (m *UpdateOAuthReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateOAuthReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpdateOAuthReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpdateOAuthReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpdateOAuthReqValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return UpdateOAuthReqMultiError(errors)
	}

	return nil
}

// UpdateOAuthReqMultiError is an error wrapping multiple validation errors
// returned by UpdateOAuthReq.ValidateAll() if the designated constraints
// aren't met.
type UpdateOAuthReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateOAuthReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateOAuthReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateOAuthReqValidationError) 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 %sUpdateOAuthReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateOAuthReqValidationError{}

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

// Validate checks the field values on RefreshTokenReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *RefreshTokenReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RefreshTokenReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// RefreshTokenReqMultiError, or nil if none found.
func (m *RefreshTokenReq) ValidateAll() error {
	return m.validate(true)
}

func (m *RefreshTokenReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for RefreshToken

	// no validation rules for PlatformID

	// no validation rules for UserID

	if len(errors) > 0 {
		return RefreshTokenReqMultiError(errors)
	}

	return nil
}

// RefreshTokenReqMultiError is an error wrapping multiple validation errors
// returned by RefreshTokenReq.ValidateAll() if the designated constraints
// aren't met.
type RefreshTokenReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m RefreshTokenReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m RefreshTokenReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e RefreshTokenReqValidationError) 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 %sRefreshTokenReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RefreshTokenReqValidationError{}

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

// Validate checks the field values on RefreshTokenResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *RefreshTokenResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RefreshTokenResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// RefreshTokenRespMultiError, or nil if none found.
func (m *RefreshTokenResp) ValidateAll() error {
	return m.validate(true)
}

func (m *RefreshTokenResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for AccessToken

	// no validation rules for PlatformUserID

	if len(errors) > 0 {
		return RefreshTokenRespMultiError(errors)
	}

	return nil
}

// RefreshTokenRespMultiError is an error wrapping multiple validation errors
// returned by RefreshTokenResp.ValidateAll() if the designated constraints
// aren't met.
type RefreshTokenRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m RefreshTokenRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m RefreshTokenRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e RefreshTokenRespValidationError) 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 %sRefreshTokenResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RefreshTokenRespValidationError{}

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

// Validate checks the field values on PublishMediaInfoReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *PublishMediaInfoReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PublishMediaInfoReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// PublishMediaInfoReqMultiError, or nil if none found.
func (m *PublishMediaInfoReq) ValidateAll() error {
	return m.validate(true)
}

func (m *PublishMediaInfoReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for PlatformID

	// no validation rules for PlatformMediaUuid

	if len(errors) > 0 {
		return PublishMediaInfoReqMultiError(errors)
	}

	return nil
}

// PublishMediaInfoReqMultiError is an error wrapping multiple validation
// errors returned by PublishMediaInfoReq.ValidateAll() if the designated
// constraints aren't met.
type PublishMediaInfoReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m PublishMediaInfoReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m PublishMediaInfoReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e PublishMediaInfoReqValidationError) 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 %sPublishMediaInfoReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PublishMediaInfoReqValidationError{}

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

// Validate checks the field values on PublishMediaInfoResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *PublishMediaInfoResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PublishMediaInfoResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// PublishMediaInfoRespMultiError, or nil if none found.
func (m *PublishMediaInfoResp) ValidateAll() error {
	return m.validate(true)
}

func (m *PublishMediaInfoResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for PlatformID

	// no validation rules for PlatformMediaUuid

	// no validation rules for Info

	if len(errors) > 0 {
		return PublishMediaInfoRespMultiError(errors)
	}

	return nil
}

// PublishMediaInfoRespMultiError is an error wrapping multiple validation
// errors returned by PublishMediaInfoResp.ValidateAll() if the designated
// constraints aren't met.
type PublishMediaInfoRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m PublishMediaInfoRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m PublishMediaInfoRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e PublishMediaInfoRespValidationError) 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 %sPublishMediaInfoResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PublishMediaInfoRespValidationError{}

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

// Validate checks the field values on ToolsReq with the rules defined in the
// proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *ToolsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ToolsReq with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in ToolsReqMultiError, or nil
// if none found.
func (m *ToolsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ToolsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Action

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return ToolsReqMultiError(errors)
	}

	return nil
}

// ToolsReqMultiError is an error wrapping multiple validation errors returned
// by ToolsReq.ValidateAll() if the designated constraints aren't met.
type ToolsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ToolsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ToolsReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ToolsReqValidationError) 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 %sToolsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ToolsReqValidationError{}

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

// Validate checks the field values on UpdateVideoScriptReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateVideoScriptReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateVideoScriptReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateVideoScriptReqMultiError, or nil if none found.
func (m *UpdateVideoScriptReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateVideoScriptReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Title

	// no validation rules for Content

	// no validation rules for CreatorUuid

	// no validation rules for CreatorName

	// no validation rules for ArtistUuid

	// no validation rules for ArtistPhone

	// no validation rules for ArtistNum

	// no validation rules for ArtistName

	if len(errors) > 0 {
		return UpdateVideoScriptReqMultiError(errors)
	}

	return nil
}

// UpdateVideoScriptReqMultiError is an error wrapping multiple validation
// errors returned by UpdateVideoScriptReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateVideoScriptReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateVideoScriptReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateVideoScriptReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateVideoScriptReqValidationError) 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 %sUpdateVideoScriptReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateVideoScriptReqValidationError{}

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

// Validate checks the field values on UpdateVideoScriptResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateVideoScriptResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateVideoScriptResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateVideoScriptRespMultiError, or nil if none found.
func (m *UpdateVideoScriptResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateVideoScriptResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return UpdateVideoScriptRespMultiError(errors)
	}

	return nil
}

// UpdateVideoScriptRespMultiError is an error wrapping multiple validation
// errors returned by UpdateVideoScriptResp.ValidateAll() if the designated
// constraints aren't met.
type UpdateVideoScriptRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateVideoScriptRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateVideoScriptRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateVideoScriptRespValidationError) 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 %sUpdateVideoScriptResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateVideoScriptRespValidationError{}

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

// Validate checks the field values on GetVideoScriptReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetVideoScriptReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetVideoScriptReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetVideoScriptReqMultiError, or nil if none found.
func (m *GetVideoScriptReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetVideoScriptReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return GetVideoScriptReqMultiError(errors)
	}

	return nil
}

// GetVideoScriptReqMultiError is an error wrapping multiple validation errors
// returned by GetVideoScriptReq.ValidateAll() if the designated constraints
// aren't met.
type GetVideoScriptReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetVideoScriptReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetVideoScriptReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetVideoScriptReqValidationError) 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 %sGetVideoScriptReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetVideoScriptReqValidationError{}

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

// Validate checks the field values on GetVideoScriptResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetVideoScriptResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetVideoScriptResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetVideoScriptRespMultiError, or nil if none found.
func (m *GetVideoScriptResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetVideoScriptResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Title

	// no validation rules for Content

	// no validation rules for Status

	// no validation rules for ArtistUuid

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for CreatorUuid

	// no validation rules for CreatorName

	// no validation rules for QuoteCount

	// no validation rules for ArtistNum

	// no validation rules for Remark

	// no validation rules for ApprovalID

	if len(errors) > 0 {
		return GetVideoScriptRespMultiError(errors)
	}

	return nil
}

// GetVideoScriptRespMultiError is an error wrapping multiple validation errors
// returned by GetVideoScriptResp.ValidateAll() if the designated constraints
// aren't met.
type GetVideoScriptRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetVideoScriptRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetVideoScriptRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetVideoScriptRespValidationError) 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 %sGetVideoScriptResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetVideoScriptRespValidationError{}

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

// Validate checks the field values on ListVideoScriptsReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListVideoScriptsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListVideoScriptsReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListVideoScriptsReqMultiError, or nil if none found.
func (m *ListVideoScriptsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListVideoScriptsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Title

	// no validation rules for Status

	// no validation rules for ArtistKeywords

	// no validation rules for CreatorKeywords

	// no validation rules for CreateStartDate

	// no validation rules for CreateEndDate

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return ListVideoScriptsReqMultiError(errors)
	}

	return nil
}

// ListVideoScriptsReqMultiError is an error wrapping multiple validation
// errors returned by ListVideoScriptsReq.ValidateAll() if the designated
// constraints aren't met.
type ListVideoScriptsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListVideoScriptsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListVideoScriptsReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ListVideoScriptsReqValidationError) 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 %sListVideoScriptsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListVideoScriptsReqValidationError{}

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

// Validate checks the field values on VideoScriptInfo with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *VideoScriptInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on VideoScriptInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// VideoScriptInfoMultiError, or nil if none found.
func (m *VideoScriptInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *VideoScriptInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Title

	// no validation rules for Content

	// no validation rules for ArtistUuid

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for QuoteCount

	// no validation rules for CreatorUuid

	// no validation rules for CreatorName

	// no validation rules for Status

	// no validation rules for CreatedDate

	// no validation rules for ArtistNum

	// no validation rules for Remark

	// no validation rules for Success

	// no validation rules for ApprovalID

	if len(errors) > 0 {
		return VideoScriptInfoMultiError(errors)
	}

	return nil
}

// VideoScriptInfoMultiError is an error wrapping multiple validation errors
// returned by VideoScriptInfo.ValidateAll() if the designated constraints
// aren't met.
type VideoScriptInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m VideoScriptInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m VideoScriptInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e VideoScriptInfoValidationError) 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 %sVideoScriptInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = VideoScriptInfoValidationError{}

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

// Validate checks the field values on ListVideoScriptsResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListVideoScriptsResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListVideoScriptsResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListVideoScriptsRespMultiError, or nil if none found.
func (m *ListVideoScriptsResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListVideoScriptsResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListVideoScriptsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListVideoScriptsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListVideoScriptsRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ListVideoScriptsRespMultiError(errors)
	}

	return nil
}

// ListVideoScriptsRespMultiError is an error wrapping multiple validation
// errors returned by ListVideoScriptsResp.ValidateAll() if the designated
// constraints aren't met.
type ListVideoScriptsRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListVideoScriptsRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListVideoScriptsRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ListVideoScriptsRespValidationError) 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 %sListVideoScriptsResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListVideoScriptsRespValidationError{}

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

// Validate checks the field values on DeleteVideoScriptReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *DeleteVideoScriptReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DeleteVideoScriptReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// DeleteVideoScriptReqMultiError, or nil if none found.
func (m *DeleteVideoScriptReq) ValidateAll() error {
	return m.validate(true)
}

func (m *DeleteVideoScriptReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return DeleteVideoScriptReqMultiError(errors)
	}

	return nil
}

// DeleteVideoScriptReqMultiError is an error wrapping multiple validation
// errors returned by DeleteVideoScriptReq.ValidateAll() if the designated
// constraints aren't met.
type DeleteVideoScriptReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m DeleteVideoScriptReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m DeleteVideoScriptReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e DeleteVideoScriptReqValidationError) 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 %sDeleteVideoScriptReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DeleteVideoScriptReqValidationError{}

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

// Validate checks the field values on UpdateVideoScriptBatchReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateVideoScriptBatchReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateVideoScriptBatchReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateVideoScriptBatchReqMultiError, or nil if none found.
func (m *UpdateVideoScriptBatchReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateVideoScriptBatchReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpdateVideoScriptBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpdateVideoScriptBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpdateVideoScriptBatchReqValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return UpdateVideoScriptBatchReqMultiError(errors)
	}

	return nil
}

// UpdateVideoScriptBatchReqMultiError is an error wrapping multiple validation
// errors returned by UpdateVideoScriptBatchReq.ValidateAll() if the
// designated constraints aren't met.
type UpdateVideoScriptBatchReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateVideoScriptBatchReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateVideoScriptBatchReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateVideoScriptBatchReqValidationError) 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 %sUpdateVideoScriptBatchReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateVideoScriptBatchReqValidationError{}

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

// Validate checks the field values on UpdateVideoScriptBatchResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateVideoScriptBatchResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateVideoScriptBatchResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateVideoScriptBatchRespMultiError, or nil if none found.
func (m *UpdateVideoScriptBatchResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateVideoScriptBatchResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpdateVideoScriptBatchRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpdateVideoScriptBatchRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpdateVideoScriptBatchRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for SuccessCount

	// no validation rules for FailCount

	if len(errors) > 0 {
		return UpdateVideoScriptBatchRespMultiError(errors)
	}

	return nil
}

// UpdateVideoScriptBatchRespMultiError is an error wrapping multiple
// validation errors returned by UpdateVideoScriptBatchResp.ValidateAll() if
// the designated constraints aren't met.
type UpdateVideoScriptBatchRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateVideoScriptBatchRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateVideoScriptBatchRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateVideoScriptBatchRespValidationError) 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 %sUpdateVideoScriptBatchResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateVideoScriptBatchRespValidationError{}

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

// Validate checks the field values on UpdateScriptStatusReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateScriptStatusReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateScriptStatusReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateScriptStatusReqMultiError, or nil if none found.
func (m *UpdateScriptStatusReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateScriptStatusReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkAction

	// no validation rules for Uuid

	// no validation rules for ApprovalID

	// no validation rules for ApprovalReply

	// no validation rules for ApprovalTime

	if len(errors) > 0 {
		return UpdateScriptStatusReqMultiError(errors)
	}

	return nil
}

// UpdateScriptStatusReqMultiError is an error wrapping multiple validation
// errors returned by UpdateScriptStatusReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateScriptStatusReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateScriptStatusReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateScriptStatusReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateScriptStatusReqValidationError) 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 %sUpdateScriptStatusReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateScriptStatusReqValidationError{}

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

// Validate checks the field values on SetLayoutReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *SetLayoutReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SetLayoutReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in SetLayoutReqMultiError, or
// nil if none found.
func (m *SetLayoutReq) ValidateAll() error {
	return m.validate(true)
}

func (m *SetLayoutReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for UserID

	// no validation rules for Data

	// no validation rules for FormName

	if len(errors) > 0 {
		return SetLayoutReqMultiError(errors)
	}

	return nil
}

// SetLayoutReqMultiError is an error wrapping multiple validation errors
// returned by SetLayoutReq.ValidateAll() if the designated constraints aren't met.
type SetLayoutReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SetLayoutReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SetLayoutReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e SetLayoutReqValidationError) 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 %sSetLayoutReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SetLayoutReqValidationError{}

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

// Validate checks the field values on GetLayoutReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *GetLayoutReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetLayoutReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in GetLayoutReqMultiError, or
// nil if none found.
func (m *GetLayoutReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetLayoutReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for UserID

	// no validation rules for FormName

	if len(errors) > 0 {
		return GetLayoutReqMultiError(errors)
	}

	return nil
}

// GetLayoutReqMultiError is an error wrapping multiple validation errors
// returned by GetLayoutReq.ValidateAll() if the designated constraints aren't met.
type GetLayoutReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetLayoutReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetLayoutReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetLayoutReqValidationError) 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 %sGetLayoutReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetLayoutReqValidationError{}

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

// Validate checks the field values on GetLayoutResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *GetLayoutResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetLayoutResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in GetLayoutRespMultiError, or
// nil if none found.
func (m *GetLayoutResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetLayoutResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Data

	// no validation rules for FormName

	if len(errors) > 0 {
		return GetLayoutRespMultiError(errors)
	}

	return nil
}

// GetLayoutRespMultiError is an error wrapping multiple validation errors
// returned by GetLayoutResp.ValidateAll() if the designated constraints
// aren't met.
type GetLayoutRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetLayoutRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetLayoutRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetLayoutRespValidationError) 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 %sGetLayoutResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetLayoutRespValidationError{}

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

// Validate checks the field values on UpdatePromptReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UpdatePromptReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdatePromptReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdatePromptReqMultiError, or nil if none found.
func (m *UpdatePromptReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdatePromptReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PromptUuid

	// no validation rules for Prompt

	// no validation rules for Category

	if len(errors) > 0 {
		return UpdatePromptReqMultiError(errors)
	}

	return nil
}

// UpdatePromptReqMultiError is an error wrapping multiple validation errors
// returned by UpdatePromptReq.ValidateAll() if the designated constraints
// aren't met.
type UpdatePromptReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdatePromptReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdatePromptReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdatePromptReqValidationError) 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 %sUpdatePromptReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdatePromptReqValidationError{}

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

// Validate checks the field values on DeletePromptReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *DeletePromptReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DeletePromptReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// DeletePromptReqMultiError, or nil if none found.
func (m *DeletePromptReq) ValidateAll() error {
	return m.validate(true)
}

func (m *DeletePromptReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PromptUuid

	if len(errors) > 0 {
		return DeletePromptReqMultiError(errors)
	}

	return nil
}

// DeletePromptReqMultiError is an error wrapping multiple validation errors
// returned by DeletePromptReq.ValidateAll() if the designated constraints
// aren't met.
type DeletePromptReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m DeletePromptReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m DeletePromptReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e DeletePromptReqValidationError) 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 %sDeletePromptReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DeletePromptReqValidationError{}

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

// Validate checks the field values on GetPromptReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *GetPromptReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetPromptReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in GetPromptReqMultiError, or
// nil if none found.
func (m *GetPromptReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetPromptReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PromptUuid

	if len(errors) > 0 {
		return GetPromptReqMultiError(errors)
	}

	return nil
}

// GetPromptReqMultiError is an error wrapping multiple validation errors
// returned by GetPromptReq.ValidateAll() if the designated constraints aren't met.
type GetPromptReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetPromptReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetPromptReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetPromptReqValidationError) 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 %sGetPromptReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetPromptReqValidationError{}

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

// Validate checks the field values on GetPromptResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *GetPromptResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetPromptResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in GetPromptRespMultiError, or
// nil if none found.
func (m *GetPromptResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetPromptResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PromptUuid

	// no validation rules for Prompt

	// no validation rules for Category

	// no validation rules for UseCount

	if len(errors) > 0 {
		return GetPromptRespMultiError(errors)
	}

	return nil
}

// GetPromptRespMultiError is an error wrapping multiple validation errors
// returned by GetPromptResp.ValidateAll() if the designated constraints
// aren't met.
type GetPromptRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetPromptRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetPromptRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetPromptRespValidationError) 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 %sGetPromptResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetPromptRespValidationError{}

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

// Validate checks the field values on ListPromptsReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *ListPromptsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListPromptsReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in ListPromptsReqMultiError,
// or nil if none found.
func (m *ListPromptsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListPromptsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Prompt

	// no validation rules for Category

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for Rand

	// no validation rules for StartUseCount

	// no validation rules for EndUseCount

	if len(errors) > 0 {
		return ListPromptsReqMultiError(errors)
	}

	return nil
}

// ListPromptsReqMultiError is an error wrapping multiple validation errors
// returned by ListPromptsReq.ValidateAll() if the designated constraints
// aren't met.
type ListPromptsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListPromptsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListPromptsReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ListPromptsReqValidationError) 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 %sListPromptsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListPromptsReqValidationError{}

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

// Validate checks the field values on PromptInfo with the rules defined in the
// proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *PromptInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PromptInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in PromptInfoMultiError, or
// nil if none found.
func (m *PromptInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *PromptInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PromptUuid

	// no validation rules for Prompt

	// no validation rules for Category

	// no validation rules for Remark

	// no validation rules for Success

	// no validation rules for UseCount

	// no validation rules for LineNo

	// no validation rules for CreatedDate

	if len(errors) > 0 {
		return PromptInfoMultiError(errors)
	}

	return nil
}

// PromptInfoMultiError is an error wrapping multiple validation errors
// returned by PromptInfo.ValidateAll() if the designated constraints aren't met.
type PromptInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m PromptInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m PromptInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e PromptInfoValidationError) 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 %sPromptInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PromptInfoValidationError{}

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

// Validate checks the field values on ListPromptsResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *ListPromptsResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListPromptsResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListPromptsRespMultiError, or nil if none found.
func (m *ListPromptsResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListPromptsResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListPromptsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListPromptsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListPromptsRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ListPromptsRespMultiError(errors)
	}

	return nil
}

// ListPromptsRespMultiError is an error wrapping multiple validation errors
// returned by ListPromptsResp.ValidateAll() if the designated constraints
// aren't met.
type ListPromptsRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListPromptsRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListPromptsRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ListPromptsRespValidationError) 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 %sListPromptsResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListPromptsRespValidationError{}

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

// Validate checks the field values on UpdatePromptBatchReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdatePromptBatchReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdatePromptBatchReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdatePromptBatchReqMultiError, or nil if none found.
func (m *UpdatePromptBatchReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdatePromptBatchReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpdatePromptBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpdatePromptBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpdatePromptBatchReqValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return UpdatePromptBatchReqMultiError(errors)
	}

	return nil
}

// UpdatePromptBatchReqMultiError is an error wrapping multiple validation
// errors returned by UpdatePromptBatchReq.ValidateAll() if the designated
// constraints aren't met.
type UpdatePromptBatchReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdatePromptBatchReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdatePromptBatchReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdatePromptBatchReqValidationError) 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 %sUpdatePromptBatchReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdatePromptBatchReqValidationError{}

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

// Validate checks the field values on UpdatePromptBatchResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdatePromptBatchResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdatePromptBatchResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdatePromptBatchRespMultiError, or nil if none found.
func (m *UpdatePromptBatchResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdatePromptBatchResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpdatePromptBatchRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpdatePromptBatchRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpdatePromptBatchRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for SuccessCount

	// no validation rules for FailCount

	if len(errors) > 0 {
		return UpdatePromptBatchRespMultiError(errors)
	}

	return nil
}

// UpdatePromptBatchRespMultiError is an error wrapping multiple validation
// errors returned by UpdatePromptBatchResp.ValidateAll() if the designated
// constraints aren't met.
type UpdatePromptBatchRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdatePromptBatchRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdatePromptBatchRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdatePromptBatchRespValidationError) 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 %sUpdatePromptBatchResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdatePromptBatchRespValidationError{}

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

// Validate checks the field values on ArtistInfo with the rules defined in the
// proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *ArtistInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in ArtistInfoMultiError, or
// nil if none found.
func (m *ArtistInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for RefID

	// no validation rules for ProfileKey

	// no validation rules for SubNum

	if len(errors) > 0 {
		return ArtistInfoMultiError(errors)
	}

	return nil
}

// ArtistInfoMultiError is an error wrapping multiple validation errors
// returned by ArtistInfo.ValidateAll() if the designated constraints aren't met.
type ArtistInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ArtistInfoValidationError) 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 %sArtistInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistInfoValidationError{}

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

// Validate checks the field values on UpdateArtistReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UpdateArtistReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateArtistReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateArtistReqMultiError, or nil if none found.
func (m *UpdateArtistReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateArtistReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if all {
		switch v := interface{}(m.GetArtistInfo()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, UpdateArtistReqValidationError{
					field:  "ArtistInfo",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, UpdateArtistReqValidationError{
					field:  "ArtistInfo",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetArtistInfo()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return UpdateArtistReqValidationError{
				field:  "ArtistInfo",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for Uuid

	if len(errors) > 0 {
		return UpdateArtistReqMultiError(errors)
	}

	return nil
}

// UpdateArtistReqMultiError is an error wrapping multiple validation errors
// returned by UpdateArtistReq.ValidateAll() if the designated constraints
// aren't met.
type UpdateArtistReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateArtistReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateArtistReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateArtistReqValidationError) 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 %sUpdateArtistReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateArtistReqValidationError{}

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

// Validate checks the field values on UpdateArtistResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UpdateArtistResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateArtistResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateArtistRespMultiError, or nil if none found.
func (m *UpdateArtistResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateArtistResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return UpdateArtistRespMultiError(errors)
	}

	return nil
}

// UpdateArtistRespMultiError is an error wrapping multiple validation errors
// returned by UpdateArtistResp.ValidateAll() if the designated constraints
// aren't met.
type UpdateArtistRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateArtistRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateArtistRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateArtistRespValidationError) 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 %sUpdateArtistResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateArtistRespValidationError{}

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

// Validate checks the field values on GetArtistReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *GetArtistReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetArtistReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in GetArtistReqMultiError, or
// nil if none found.
func (m *GetArtistReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetArtistReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return GetArtistReqMultiError(errors)
	}

	return nil
}

// GetArtistReqMultiError is an error wrapping multiple validation errors
// returned by GetArtistReq.ValidateAll() if the designated constraints aren't met.
type GetArtistReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetArtistReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetArtistReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetArtistReqValidationError) 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 %sGetArtistReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetArtistReqValidationError{}

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

// Validate checks the field values on GetArtistResp with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *GetArtistResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetArtistResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in GetArtistRespMultiError, or
// nil if none found.
func (m *GetArtistResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetArtistResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if all {
		switch v := interface{}(m.GetArtistInfo()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetArtistRespValidationError{
					field:  "ArtistInfo",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetArtistRespValidationError{
					field:  "ArtistInfo",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetArtistInfo()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetArtistRespValidationError{
				field:  "ArtistInfo",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for Uuid

	if len(errors) > 0 {
		return GetArtistRespMultiError(errors)
	}

	return nil
}

// GetArtistRespMultiError is an error wrapping multiple validation errors
// returned by GetArtistResp.ValidateAll() if the designated constraints
// aren't met.
type GetArtistRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetArtistRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetArtistRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetArtistRespValidationError) 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 %sGetArtistResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetArtistRespValidationError{}

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

// Validate checks the field values on CreateWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CreateWorkAnalysisReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CreateWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CreateWorkAnalysisReqMultiError, or nil if none found.
func (m *CreateWorkAnalysisReq) ValidateAll() error {
	return m.validate(true)
}

func (m *CreateWorkAnalysisReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SubNum

	// no validation rules for ArtistName

	// no validation rules for ArtistID

	// no validation rules for ArtistPhone

	// no validation rules for Analysis

	// no validation rules for Title

	// no validation rules for PdfUrl

	// no validation rules for MediaAccountCount

	// no validation rules for WorkVideoCount

	// no validation rules for WorkImageCount

	// no validation rules for Views

	// no validation rules for Likes

	// no validation rules for Comments

	// no validation rules for Shares

	// no validation rules for FansCount

	// no validation rules for TopCities

	// no validation rules for MostActiveDay

	// no validation rules for BestPostTime

	// no validation rules for PeriodTypeFans

	// no validation rules for PeriodTypeViews

	// no validation rules for PeriodTypeLikes

	// no validation rules for PeriodTypeComments

	// no validation rules for PeriodTypeShares

	// no validation rules for BundleOrderUuid

	// no validation rules for Date

	if len(errors) > 0 {
		return CreateWorkAnalysisReqMultiError(errors)
	}

	return nil
}

// CreateWorkAnalysisReqMultiError is an error wrapping multiple validation
// errors returned by CreateWorkAnalysisReq.ValidateAll() if the designated
// constraints aren't met.
type CreateWorkAnalysisReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CreateWorkAnalysisReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CreateWorkAnalysisReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e CreateWorkAnalysisReqValidationError) 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 %sCreateWorkAnalysisReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CreateWorkAnalysisReqValidationError{}

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

// Validate checks the field values on CreateWorkAnalysisResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CreateWorkAnalysisResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CreateWorkAnalysisResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CreateWorkAnalysisRespMultiError, or nil if none found.
func (m *CreateWorkAnalysisResp) ValidateAll() error {
	return m.validate(true)
}

func (m *CreateWorkAnalysisResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return CreateWorkAnalysisRespMultiError(errors)
	}

	return nil
}

// CreateWorkAnalysisRespMultiError is an error wrapping multiple validation
// errors returned by CreateWorkAnalysisResp.ValidateAll() if the designated
// constraints aren't met.
type CreateWorkAnalysisRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CreateWorkAnalysisRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CreateWorkAnalysisRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e CreateWorkAnalysisRespValidationError) 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 %sCreateWorkAnalysisResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CreateWorkAnalysisRespValidationError{}

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

// Validate checks the field values on ImportWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ImportWorkAnalysisReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ImportWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ImportWorkAnalysisReqMultiError, or nil if none found.
func (m *ImportWorkAnalysisReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ImportWorkAnalysisReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SubNum

	// no validation rules for ArtistName

	// no validation rules for ArtistID

	// no validation rules for ArtistPhone

	// no validation rules for Analysis

	// no validation rules for Title

	// no validation rules for PdfUrl

	// no validation rules for MediaAccountCount

	// no validation rules for WorkVideoCount

	// no validation rules for WorkImageCount

	// no validation rules for Views

	// no validation rules for Likes

	// no validation rules for Comments

	// no validation rules for Shares

	// no validation rules for FansCount

	// no validation rules for TopCities

	// no validation rules for MostActiveDay

	// no validation rules for BestPostTime

	// no validation rules for PeriodTypeFans

	// no validation rules for PeriodTypeViews

	// no validation rules for PeriodTypeLikes

	// no validation rules for PeriodTypeComments

	// no validation rules for PeriodTypeShares

	// no validation rules for BundleOrderUuid

	// no validation rules for Date

	// no validation rules for SubmitTime

	// no validation rules for IsRefreshData

	// no validation rules for ConfirmType

	if len(errors) > 0 {
		return ImportWorkAnalysisReqMultiError(errors)
	}

	return nil
}

// ImportWorkAnalysisReqMultiError is an error wrapping multiple validation
// errors returned by ImportWorkAnalysisReq.ValidateAll() if the designated
// constraints aren't met.
type ImportWorkAnalysisReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ImportWorkAnalysisReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ImportWorkAnalysisReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ImportWorkAnalysisReqValidationError) 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 %sImportWorkAnalysisReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ImportWorkAnalysisReqValidationError{}

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

// Validate checks the field values on ImportWorkAnalysisResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ImportWorkAnalysisResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ImportWorkAnalysisResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ImportWorkAnalysisRespMultiError, or nil if none found.
func (m *ImportWorkAnalysisResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ImportWorkAnalysisResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return ImportWorkAnalysisRespMultiError(errors)
	}

	return nil
}

// ImportWorkAnalysisRespMultiError is an error wrapping multiple validation
// errors returned by ImportWorkAnalysisResp.ValidateAll() if the designated
// constraints aren't met.
type ImportWorkAnalysisRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ImportWorkAnalysisRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ImportWorkAnalysisRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ImportWorkAnalysisRespValidationError) 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 %sImportWorkAnalysisResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ImportWorkAnalysisRespValidationError{}

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

// Validate checks the field values on UpdateWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkAnalysisReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkAnalysisReqMultiError, or nil if none found.
func (m *UpdateWorkAnalysisReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkAnalysisReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Analysis

	// no validation rules for Title

	// no validation rules for PdfUrl

	// no validation rules for MediaAccountCount

	// no validation rules for WorkVideoCount

	// no validation rules for WorkImageCount

	// no validation rules for Views

	// no validation rules for Likes

	// no validation rules for Comments

	// no validation rules for Shares

	// no validation rules for FansCount

	// no validation rules for TopCities

	// no validation rules for MostActiveDay

	// no validation rules for BestPostTime

	// no validation rules for ArtistUUID

	// no validation rules for PeriodTypeFans

	// no validation rules for PeriodTypeViews

	// no validation rules for PeriodTypeLikes

	// no validation rules for PeriodTypeComments

	// no validation rules for PeriodTypeShares

	// no validation rules for BundleOrderUuid

	// no validation rules for Date

	if len(errors) > 0 {
		return UpdateWorkAnalysisReqMultiError(errors)
	}

	return nil
}

// UpdateWorkAnalysisReqMultiError is an error wrapping multiple validation
// errors returned by UpdateWorkAnalysisReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateWorkAnalysisReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkAnalysisReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkAnalysisReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateWorkAnalysisReqValidationError) 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 %sUpdateWorkAnalysisReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkAnalysisReqValidationError{}

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

// Validate checks the field values on UpdateWorkAnalysisStatusReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkAnalysisStatusReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkAnalysisStatusReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkAnalysisStatusReqMultiError, or nil if none found.
func (m *UpdateWorkAnalysisStatusReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkAnalysisStatusReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkAction

	// no validation rules for Uuid

	// no validation rules for ApprovalID

	// no validation rules for ApprovalReply

	// no validation rules for ConfirmRemark

	// no validation rules for ConfirmStatus

	// no validation rules for CostType

	// no validation rules for ConfirmType

	// no validation rules for ApprovalTime

	if len(errors) > 0 {
		return UpdateWorkAnalysisStatusReqMultiError(errors)
	}

	return nil
}

// UpdateWorkAnalysisStatusReqMultiError is an error wrapping multiple
// validation errors returned by UpdateWorkAnalysisStatusReq.ValidateAll() if
// the designated constraints aren't met.
type UpdateWorkAnalysisStatusReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkAnalysisStatusReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkAnalysisStatusReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e UpdateWorkAnalysisStatusReqValidationError) 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 %sUpdateWorkAnalysisStatusReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkAnalysisStatusReqValidationError{}

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

// Validate checks the field values on WorkAnalysisLogInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisLogInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisLogInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisLogInfoMultiError, or nil if none found.
func (m *WorkAnalysisLogInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisLogInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for Title

	// no validation rules for UpdateTime

	// no validation rules for WorkAnalysisStatus

	// no validation rules for ArtistName

	// no validation rules for ArtistUuid

	// no validation rules for AnalysisExtraData

	// no validation rules for OperatorName

	// no validation rules for OperatorID

	if len(errors) > 0 {
		return WorkAnalysisLogInfoMultiError(errors)
	}

	return nil
}

// WorkAnalysisLogInfoMultiError is an error wrapping multiple validation
// errors returned by WorkAnalysisLogInfo.ValidateAll() if the designated
// constraints aren't met.
type WorkAnalysisLogInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisLogInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisLogInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisLogInfoValidationError) 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 %sWorkAnalysisLogInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisLogInfoValidationError{}

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

// Validate checks the field values on WorkAnalysisFansSeries with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisFansSeries) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisFansSeries with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisFansSeriesMultiError, or nil if none found.
func (m *WorkAnalysisFansSeries) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisFansSeries) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for FansCount

	// no validation rules for PeriodType

	// no validation rules for StartDate

	// no validation rules for EndDate

	// no validation rules for DetailJSON

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkAnalysisFansSeriesMultiError(errors)
	}

	return nil
}

// WorkAnalysisFansSeriesMultiError is an error wrapping multiple validation
// errors returned by WorkAnalysisFansSeries.ValidateAll() if the designated
// constraints aren't met.
type WorkAnalysisFansSeriesMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisFansSeriesMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisFansSeriesMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisFansSeriesValidationError) 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 %sWorkAnalysisFansSeries.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisFansSeriesValidationError{}

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

// Validate checks the field values on WorkAnalysisViewsSeries with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisViewsSeries) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisViewsSeries with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisViewsSeriesMultiError, or nil if none found.
func (m *WorkAnalysisViewsSeries) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisViewsSeries) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for ViewsCount

	// no validation rules for PeriodType

	// no validation rules for StartDate

	// no validation rules for EndDate

	// no validation rules for DetailJSON

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkAnalysisViewsSeriesMultiError(errors)
	}

	return nil
}

// WorkAnalysisViewsSeriesMultiError is an error wrapping multiple validation
// errors returned by WorkAnalysisViewsSeries.ValidateAll() if the designated
// constraints aren't met.
type WorkAnalysisViewsSeriesMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisViewsSeriesMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisViewsSeriesMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisViewsSeriesValidationError) 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 %sWorkAnalysisViewsSeries.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisViewsSeriesValidationError{}

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

// Validate checks the field values on WorkAnalysisLikesSeries with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisLikesSeries) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisLikesSeries with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisLikesSeriesMultiError, or nil if none found.
func (m *WorkAnalysisLikesSeries) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisLikesSeries) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for LikesCount

	// no validation rules for PeriodType

	// no validation rules for StartDate

	// no validation rules for EndDate

	// no validation rules for DetailJSON

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkAnalysisLikesSeriesMultiError(errors)
	}

	return nil
}

// WorkAnalysisLikesSeriesMultiError is an error wrapping multiple validation
// errors returned by WorkAnalysisLikesSeries.ValidateAll() if the designated
// constraints aren't met.
type WorkAnalysisLikesSeriesMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisLikesSeriesMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisLikesSeriesMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisLikesSeriesValidationError) 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 %sWorkAnalysisLikesSeries.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisLikesSeriesValidationError{}

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

// Validate checks the field values on WorkAnalysisCommentsSeries with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisCommentsSeries) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisCommentsSeries with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisCommentsSeriesMultiError, or nil if none found.
func (m *WorkAnalysisCommentsSeries) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisCommentsSeries) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for CommentsCount

	// no validation rules for PeriodType

	// no validation rules for StartDate

	// no validation rules for EndDate

	// no validation rules for DetailJSON

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkAnalysisCommentsSeriesMultiError(errors)
	}

	return nil
}

// WorkAnalysisCommentsSeriesMultiError is an error wrapping multiple
// validation errors returned by WorkAnalysisCommentsSeries.ValidateAll() if
// the designated constraints aren't met.
type WorkAnalysisCommentsSeriesMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisCommentsSeriesMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisCommentsSeriesMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisCommentsSeriesValidationError) 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 %sWorkAnalysisCommentsSeries.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisCommentsSeriesValidationError{}

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

// Validate checks the field values on WorkAnalysisSharesSeries with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisSharesSeries) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisSharesSeries with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisSharesSeriesMultiError, or nil if none found.
func (m *WorkAnalysisSharesSeries) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisSharesSeries) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SharesCount

	// no validation rules for PeriodType

	// no validation rules for StartDate

	// no validation rules for EndDate

	// no validation rules for DetailJSON

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkAnalysisSharesSeriesMultiError(errors)
	}

	return nil
}

// WorkAnalysisSharesSeriesMultiError is an error wrapping multiple validation
// errors returned by WorkAnalysisSharesSeries.ValidateAll() if the designated
// constraints aren't met.
type WorkAnalysisSharesSeriesMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisSharesSeriesMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisSharesSeriesMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisSharesSeriesValidationError) 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 %sWorkAnalysisSharesSeries.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisSharesSeriesValidationError{}

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

// Validate checks the field values on WorkAnalysisTopCities with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisTopCities) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisTopCities with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisTopCitiesMultiError, or nil if none found.
func (m *WorkAnalysisTopCities) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisTopCities) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for CitiesJSON

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkAnalysisTopCitiesMultiError(errors)
	}

	return nil
}

// WorkAnalysisTopCitiesMultiError is an error wrapping multiple validation
// errors returned by WorkAnalysisTopCities.ValidateAll() if the designated
// constraints aren't met.
type WorkAnalysisTopCitiesMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisTopCitiesMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisTopCitiesMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisTopCitiesValidationError) 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 %sWorkAnalysisTopCities.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisTopCitiesValidationError{}

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

// Validate checks the field values on WorkAnalysisMostActiveDay with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisMostActiveDay) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisMostActiveDay with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisMostActiveDayMultiError, or nil if none found.
func (m *WorkAnalysisMostActiveDay) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisMostActiveDay) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for DetailJSON

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkAnalysisMostActiveDayMultiError(errors)
	}

	return nil
}

// WorkAnalysisMostActiveDayMultiError is an error wrapping multiple validation
// errors returned by WorkAnalysisMostActiveDay.ValidateAll() if the
// designated constraints aren't met.
type WorkAnalysisMostActiveDayMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisMostActiveDayMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisMostActiveDayMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisMostActiveDayValidationError) 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 %sWorkAnalysisMostActiveDay.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisMostActiveDayValidationError{}

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

// Validate checks the field values on WorkAnalysisBestPostTime with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisBestPostTime) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisBestPostTime with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisBestPostTimeMultiError, or nil if none found.
func (m *WorkAnalysisBestPostTime) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisBestPostTime) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for DetailJSON

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkAnalysisBestPostTimeMultiError(errors)
	}

	return nil
}

// WorkAnalysisBestPostTimeMultiError is an error wrapping multiple validation
// errors returned by WorkAnalysisBestPostTime.ValidateAll() if the designated
// constraints aren't met.
type WorkAnalysisBestPostTimeMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisBestPostTimeMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisBestPostTimeMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisBestPostTimeValidationError) 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 %sWorkAnalysisBestPostTime.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisBestPostTimeValidationError{}

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

// Validate checks the field values on WorkAnalysisExtra with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisExtra) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisExtra with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisExtraMultiError, or nil if none found.
func (m *WorkAnalysisExtra) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisExtra) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for AnalysisUuid

	// no validation rules for ArtistConfirmedTime

	// no validation rules for CostType

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkAnalysisExtraMultiError(errors)
	}

	return nil
}

// WorkAnalysisExtraMultiError is an error wrapping multiple validation errors
// returned by WorkAnalysisExtra.ValidateAll() if the designated constraints
// aren't met.
type WorkAnalysisExtraMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisExtraMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisExtraMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisExtraValidationError) 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 %sWorkAnalysisExtra.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisExtraValidationError{}

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

// Validate checks the field values on GetWorkAnalysisDetailReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetWorkAnalysisDetailReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetWorkAnalysisDetailReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetWorkAnalysisDetailReqMultiError, or nil if none found.
func (m *GetWorkAnalysisDetailReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetWorkAnalysisDetailReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return GetWorkAnalysisDetailReqMultiError(errors)
	}

	return nil
}

// GetWorkAnalysisDetailReqMultiError is an error wrapping multiple validation
// errors returned by GetWorkAnalysisDetailReq.ValidateAll() if the designated
// constraints aren't met.
type GetWorkAnalysisDetailReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetWorkAnalysisDetailReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetWorkAnalysisDetailReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetWorkAnalysisDetailReqValidationError) 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 %sGetWorkAnalysisDetailReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetWorkAnalysisDetailReqValidationError{}

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

// Validate checks the field values on GetLatestWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetLatestWorkAnalysisReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetLatestWorkAnalysisReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetLatestWorkAnalysisReqMultiError, or nil if none found.
func (m *GetLatestWorkAnalysisReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetLatestWorkAnalysisReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for SubNum

	if len(errors) > 0 {
		return GetLatestWorkAnalysisReqMultiError(errors)
	}

	return nil
}

// GetLatestWorkAnalysisReqMultiError is an error wrapping multiple validation
// errors returned by GetLatestWorkAnalysisReq.ValidateAll() if the designated
// constraints aren't met.
type GetLatestWorkAnalysisReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetLatestWorkAnalysisReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetLatestWorkAnalysisReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetLatestWorkAnalysisReqValidationError) 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 %sGetLatestWorkAnalysisReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetLatestWorkAnalysisReqValidationError{}

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

// Validate checks the field values on GetWorkAnalysisResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetWorkAnalysisResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetWorkAnalysisResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetWorkAnalysisRespMultiError, or nil if none found.
func (m *GetWorkAnalysisResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetWorkAnalysisResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SubNum

	// no validation rules for ArtistName

	// no validation rules for ArtistID

	// no validation rules for ArtistPhone

	// no validation rules for Analysis

	// no validation rules for Title

	// no validation rules for OperatorID

	// no validation rules for OperatorName

	// no validation rules for WorkAnalysisStatus

	// no validation rules for Reason

	// no validation rules for ComfirmType

	// no validation rules for Cost

	// no validation rules for SubmitTime

	// no validation rules for StatusUpdateTime

	// no validation rules for ApprovalID

	// no validation rules for PdfUrl

	// no validation rules for MediaAccountCount

	// no validation rules for WorkVideoCount

	// no validation rules for WorkImageCount

	// no validation rules for Views

	// no validation rules for Likes

	// no validation rules for Comments

	// no validation rules for Shares

	// no validation rules for FansCount

	// no validation rules for TopCities

	// no validation rules for MostActiveDay

	// no validation rules for BestPostTime

	// no validation rules for CreatedAt

	if all {
		switch v := interface{}(m.GetFansSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "FansSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "FansSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetFansSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisRespValidationError{
				field:  "FansSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetViewsSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "ViewsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "ViewsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetViewsSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisRespValidationError{
				field:  "ViewsSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetLikesSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "LikesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "LikesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetLikesSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisRespValidationError{
				field:  "LikesSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetCommentsSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "CommentsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "CommentsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetCommentsSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisRespValidationError{
				field:  "CommentsSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetSharesSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "SharesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "SharesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetSharesSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisRespValidationError{
				field:  "SharesSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetTopCitiesSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "TopCitiesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "TopCitiesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetTopCitiesSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisRespValidationError{
				field:  "TopCitiesSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetMostActiveDaySeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "MostActiveDaySeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "MostActiveDaySeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetMostActiveDaySeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisRespValidationError{
				field:  "MostActiveDaySeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetBestPostTimeSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "BestPostTimeSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisRespValidationError{
					field:  "BestPostTimeSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetBestPostTimeSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisRespValidationError{
				field:  "BestPostTimeSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return GetWorkAnalysisRespMultiError(errors)
	}

	return nil
}

// GetWorkAnalysisRespMultiError is an error wrapping multiple validation
// errors returned by GetWorkAnalysisResp.ValidateAll() if the designated
// constraints aren't met.
type GetWorkAnalysisRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetWorkAnalysisRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetWorkAnalysisRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetWorkAnalysisRespValidationError) 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 %sGetWorkAnalysisResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetWorkAnalysisRespValidationError{}

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

// Validate checks the field values on GetWorkAnalysisDetailResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetWorkAnalysisDetailResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetWorkAnalysisDetailResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetWorkAnalysisDetailRespMultiError, or nil if none found.
func (m *GetWorkAnalysisDetailResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetWorkAnalysisDetailResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SubNum

	// no validation rules for ArtistName

	// no validation rules for ArtistID

	// no validation rules for ArtistPhone

	// no validation rules for Analysis

	// no validation rules for Title

	// no validation rules for OperatorID

	// no validation rules for OperatorName

	// no validation rules for WorkAnalysisStatus

	// no validation rules for Reason

	// no validation rules for ComfirmType

	// no validation rules for Cost

	// no validation rules for SubmitTime

	// no validation rules for StatusUpdateTime

	// no validation rules for ApprovalID

	// no validation rules for PdfUrl

	// no validation rules for MediaAccountCount

	// no validation rules for WorkVideoCount

	// no validation rules for WorkImageCount

	// no validation rules for Views

	// no validation rules for Likes

	// no validation rules for Comments

	// no validation rules for Shares

	// no validation rules for FansCount

	// no validation rules for TopCities

	// no validation rules for MostActiveDay

	// no validation rules for BestPostTime

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetWorkAnalysisDetailRespValidationError{
						field:  fmt.Sprintf("WorkAnalysisLogData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetWorkAnalysisDetailRespValidationError{
						field:  fmt.Sprintf("WorkAnalysisLogData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetWorkAnalysisDetailRespValidationError{
					field:  fmt.Sprintf("WorkAnalysisLogData[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if all {
		switch v := interface{}(m.GetFansSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "FansSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "FansSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetFansSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisDetailRespValidationError{
				field:  "FansSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetViewsSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "ViewsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "ViewsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetViewsSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisDetailRespValidationError{
				field:  "ViewsSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetLikesSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "LikesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "LikesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetLikesSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisDetailRespValidationError{
				field:  "LikesSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetCommentsSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "CommentsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "CommentsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetCommentsSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisDetailRespValidationError{
				field:  "CommentsSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetSharesSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "SharesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "SharesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetSharesSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisDetailRespValidationError{
				field:  "SharesSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetTopCitiesSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "TopCitiesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "TopCitiesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetTopCitiesSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisDetailRespValidationError{
				field:  "TopCitiesSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetMostActiveDaySeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "MostActiveDaySeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "MostActiveDaySeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetMostActiveDaySeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisDetailRespValidationError{
				field:  "MostActiveDaySeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetBestPostTimeSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "BestPostTimeSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "BestPostTimeSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetBestPostTimeSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisDetailRespValidationError{
				field:  "BestPostTimeSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetExtra()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "Extra",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetWorkAnalysisDetailRespValidationError{
					field:  "Extra",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetExtra()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetWorkAnalysisDetailRespValidationError{
				field:  "Extra",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	// no validation rules for BundleOrderUuid

	if len(errors) > 0 {
		return GetWorkAnalysisDetailRespMultiError(errors)
	}

	return nil
}

// GetWorkAnalysisDetailRespMultiError is an error wrapping multiple validation
// errors returned by GetWorkAnalysisDetailResp.ValidateAll() if the
// designated constraints aren't met.
type GetWorkAnalysisDetailRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetWorkAnalysisDetailRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetWorkAnalysisDetailRespMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e GetWorkAnalysisDetailRespValidationError) 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 %sGetWorkAnalysisDetailResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetWorkAnalysisDetailRespValidationError{}

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

// Validate checks the field values on ListWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListWorkAnalysisReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListWorkAnalysisReqMultiError, or nil if none found.
func (m *ListWorkAnalysisReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListWorkAnalysisReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for SubNum

	// no validation rules for ArtistVal

	// no validation rules for Status

	// no validation rules for ComfirmType

	// no validation rules for StatusUpdateTimeStart

	// no validation rules for StatusUpdateTimeEnd

	// no validation rules for SubmitStartTime

	// no validation rules for SubmitEndTime

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return ListWorkAnalysisReqMultiError(errors)
	}

	return nil
}

// ListWorkAnalysisReqMultiError is an error wrapping multiple validation
// errors returned by ListWorkAnalysisReq.ValidateAll() if the designated
// constraints aren't met.
type ListWorkAnalysisReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListWorkAnalysisReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListWorkAnalysisReqMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e ListWorkAnalysisReqValidationError) 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 %sListWorkAnalysisReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListWorkAnalysisReqValidationError{}

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

// Validate checks the field values on WorkAnalysisInfo with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *WorkAnalysisInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkAnalysisInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkAnalysisInfoMultiError, or nil if none found.
func (m *WorkAnalysisInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkAnalysisInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SubNum

	// no validation rules for ArtistName

	// no validation rules for ArtistID

	// no validation rules for ArtistPhone

	// no validation rules for OperatorID

	// no validation rules for OperatorName

	// no validation rules for WorkAnalysisStatus

	// no validation rules for Reason

	// no validation rules for ComfirmType

	// no validation rules for SubmitTime

	// no validation rules for StatusUpdateTime

	// no validation rules for PdfUrl

	// no validation rules for ApprovalID

	// no validation rules for Title

	if len(errors) > 0 {
		return WorkAnalysisInfoMultiError(errors)
	}

	return nil
}

// WorkAnalysisInfoMultiError is an error wrapping multiple validation errors
// returned by WorkAnalysisInfo.ValidateAll() if the designated constraints
// aren't met.
type WorkAnalysisInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkAnalysisInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkAnalysisInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

// Error satisfies the builtin error interface
func (e WorkAnalysisInfoValidationError) 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 %sWorkAnalysisInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkAnalysisInfoValidationError{}

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

// Validate checks the field values on ListWorkAnalysisResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListWorkAnalysisResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListWorkAnalysisResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListWorkAnalysisRespMultiError, or nil if none found.
func (m *ListWorkAnalysisResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListWorkAnalysisResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListWorkAnalysisRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListWorkAnalysisRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListWorkAnalysisRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ListWorkAnalysisRespMultiError(errors)
	}

	return nil
}

// ListWorkAnalysisRespMultiError is an error wrapping multiple validation
// errors returned by ListWorkAnalysisResp.ValidateAll() if the designated
// constraints aren't met.
type ListWorkAnalysisRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListWorkAnalysisRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListWorkAnalysisRespMultiError) AllErrors() []error { return m }

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

// Field function returns field value.
func (e ListWorkAnalysisRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListWorkAnalysisRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListWorkAnalysisRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListWorkAnalysisRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListWorkAnalysisRespValidationError) ErrorName() string {
	return "ListWorkAnalysisRespValidationError"
}

// Error satisfies the builtin error interface
func (e ListWorkAnalysisRespValidationError) 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 %sListWorkAnalysisResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListWorkAnalysisRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListWorkAnalysisRespValidationError{}

// Validate checks the field values on DeleteWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *DeleteWorkAnalysisReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DeleteWorkAnalysisReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// DeleteWorkAnalysisReqMultiError, or nil if none found.
func (m *DeleteWorkAnalysisReq) ValidateAll() error {
	return m.validate(true)
}

func (m *DeleteWorkAnalysisReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return DeleteWorkAnalysisReqMultiError(errors)
	}

	return nil
}

// DeleteWorkAnalysisReqMultiError is an error wrapping multiple validation
// errors returned by DeleteWorkAnalysisReq.ValidateAll() if the designated
// constraints aren't met.
type DeleteWorkAnalysisReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m DeleteWorkAnalysisReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m DeleteWorkAnalysisReqMultiError) AllErrors() []error { return m }

// DeleteWorkAnalysisReqValidationError is the validation error returned by
// DeleteWorkAnalysisReq.Validate if the designated constraints aren't met.
type DeleteWorkAnalysisReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e DeleteWorkAnalysisReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e DeleteWorkAnalysisReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e DeleteWorkAnalysisReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e DeleteWorkAnalysisReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e DeleteWorkAnalysisReqValidationError) ErrorName() string {
	return "DeleteWorkAnalysisReqValidationError"
}

// Error satisfies the builtin error interface
func (e DeleteWorkAnalysisReqValidationError) 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 %sDeleteWorkAnalysisReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DeleteWorkAnalysisReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = DeleteWorkAnalysisReqValidationError{}

// Validate checks the field values on ArtistDataListReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *ArtistDataListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistDataListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ArtistDataListReqMultiError, or nil if none found.
func (m *ArtistDataListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistDataListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistVal

	// no validation rules for BundleName

	// no validation rules for ExpiredTimeStart

	// no validation rules for ExpiredTimeEnd

	// no validation rules for SubmitTimeStart

	// no validation rules for SubmitTimeEnd

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for SubNum

	if len(errors) > 0 {
		return ArtistDataListReqMultiError(errors)
	}

	return nil
}

// ArtistDataListReqMultiError is an error wrapping multiple validation errors
// returned by ArtistDataListReq.ValidateAll() if the designated constraints
// aren't met.
type ArtistDataListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistDataListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistDataListReqMultiError) AllErrors() []error { return m }

// ArtistDataListReqValidationError is the validation error returned by
// ArtistDataListReq.Validate if the designated constraints aren't met.
type ArtistDataListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ArtistDataListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ArtistDataListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ArtistDataListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ArtistDataListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ArtistDataListReqValidationError) ErrorName() string {
	return "ArtistDataListReqValidationError"
}

// Error satisfies the builtin error interface
func (e ArtistDataListReqValidationError) 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 %sArtistDataListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistDataListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ArtistDataListReqValidationError{}

// Validate checks the field values on ArtistDataRespItem with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ArtistDataRespItem) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistDataRespItem with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ArtistDataRespItemMultiError, or nil if none found.
func (m *ArtistDataRespItem) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistDataRespItem) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistName

	// no validation rules for ArtistUuid

	// no validation rules for SubNum

	// no validation rules for ArtistPhone

	// no validation rules for BundleName

	// no validation rules for AccountNumber

	// no validation rules for AccountConsumptionNumber

	// no validation rules for DataAnalysisNumber

	// no validation rules for DataAnalysisConsumptionNumber

	// no validation rules for CompetitiveNumber

	// no validation rules for CompetitiveConsumptionNumber

	// no validation rules for SubmitTime

	// no validation rules for FansCount

	// no validation rules for ViewsCount

	// no validation rules for LikesCount

	// no validation rules for CommentsCount

	// no validation rules for SharesCount

	// no validation rules for CastWorkCount

	// no validation rules for ExpiredTime

	// no validation rules for VideoCount

	// no validation rules for ImageCount

	if len(errors) > 0 {
		return ArtistDataRespItemMultiError(errors)
	}

	return nil
}

// ArtistDataRespItemMultiError is an error wrapping multiple validation errors
// returned by ArtistDataRespItem.ValidateAll() if the designated constraints
// aren't met.
type ArtistDataRespItemMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistDataRespItemMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistDataRespItemMultiError) AllErrors() []error { return m }

// ArtistDataRespItemValidationError is the validation error returned by
// ArtistDataRespItem.Validate if the designated constraints aren't met.
type ArtistDataRespItemValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ArtistDataRespItemValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ArtistDataRespItemValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ArtistDataRespItemValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ArtistDataRespItemValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ArtistDataRespItemValidationError) ErrorName() string {
	return "ArtistDataRespItemValidationError"
}

// Error satisfies the builtin error interface
func (e ArtistDataRespItemValidationError) 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 %sArtistDataRespItem.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistDataRespItemValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ArtistDataRespItemValidationError{}

// Validate checks the field values on ArtistDataListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ArtistDataListResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistDataListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ArtistDataListRespMultiError, or nil if none found.
func (m *ArtistDataListResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistDataListResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ArtistDataListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ArtistDataListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ArtistDataListRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ArtistDataListRespMultiError(errors)
	}

	return nil
}

// ArtistDataListRespMultiError is an error wrapping multiple validation errors
// returned by ArtistDataListResp.ValidateAll() if the designated constraints
// aren't met.
type ArtistDataListRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistDataListRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistDataListRespMultiError) AllErrors() []error { return m }

// ArtistDataListRespValidationError is the validation error returned by
// ArtistDataListResp.Validate if the designated constraints aren't met.
type ArtistDataListRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ArtistDataListRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ArtistDataListRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ArtistDataListRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ArtistDataListRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ArtistDataListRespValidationError) ErrorName() string {
	return "ArtistDataListRespValidationError"
}

// Error satisfies the builtin error interface
func (e ArtistDataListRespValidationError) 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 %sArtistDataListResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistDataListRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ArtistDataListRespValidationError{}

// Validate checks the field values on MediaDataListReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *MediaDataListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaDataListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaDataListReqMultiError, or nil if none found.
func (m *MediaDataListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaDataListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistVal

	// no validation rules for PlatformUserName

	// no validation rules for PlatformID

	// no validation rules for Page

	// no validation rules for PageSize

	if len(errors) > 0 {
		return MediaDataListReqMultiError(errors)
	}

	return nil
}

// MediaDataListReqMultiError is an error wrapping multiple validation errors
// returned by MediaDataListReq.ValidateAll() if the designated constraints
// aren't met.
type MediaDataListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaDataListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaDataListReqMultiError) AllErrors() []error { return m }

// MediaDataListReqValidationError is the validation error returned by
// MediaDataListReq.Validate if the designated constraints aren't met.
type MediaDataListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MediaDataListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MediaDataListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MediaDataListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MediaDataListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MediaDataListReqValidationError) ErrorName() string { return "MediaDataListReqValidationError" }

// Error satisfies the builtin error interface
func (e MediaDataListReqValidationError) 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 %sMediaDataListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaDataListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MediaDataListReqValidationError{}

// Validate checks the field values on MediaDataListItem with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *MediaDataListItem) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaDataListItem with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaDataListItemMultiError, or nil if none found.
func (m *MediaDataListItem) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaDataListItem) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistName

	// no validation rules for ArtistUuid

	// no validation rules for SubNum

	// no validation rules for ArtistPhone

	// no validation rules for PlatformUserName

	// no validation rules for PlatformID

	// no validation rules for SubmitTime

	// no validation rules for FansCount

	// no validation rules for ViewsCount

	// no validation rules for LikesCount

	// no validation rules for CommentsCount

	// no validation rules for SharesCount

	// no validation rules for CastWorkCount

	// no validation rules for VideoCount

	// no validation rules for ImageCount

	if len(errors) > 0 {
		return MediaDataListItemMultiError(errors)
	}

	return nil
}

// MediaDataListItemMultiError is an error wrapping multiple validation errors
// returned by MediaDataListItem.ValidateAll() if the designated constraints
// aren't met.
type MediaDataListItemMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaDataListItemMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaDataListItemMultiError) AllErrors() []error { return m }

// MediaDataListItemValidationError is the validation error returned by
// MediaDataListItem.Validate if the designated constraints aren't met.
type MediaDataListItemValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MediaDataListItemValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MediaDataListItemValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MediaDataListItemValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MediaDataListItemValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MediaDataListItemValidationError) ErrorName() string {
	return "MediaDataListItemValidationError"
}

// Error satisfies the builtin error interface
func (e MediaDataListItemValidationError) 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 %sMediaDataListItem.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaDataListItemValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MediaDataListItemValidationError{}

// Validate checks the field values on MediaDataListResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *MediaDataListResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaDataListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaDataListRespMultiError, or nil if none found.
func (m *MediaDataListResp) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaDataListResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, MediaDataListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, MediaDataListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MediaDataListRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return MediaDataListRespMultiError(errors)
	}

	return nil
}

// MediaDataListRespMultiError is an error wrapping multiple validation errors
// returned by MediaDataListResp.ValidateAll() if the designated constraints
// aren't met.
type MediaDataListRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaDataListRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaDataListRespMultiError) AllErrors() []error { return m }

// MediaDataListRespValidationError is the validation error returned by
// MediaDataListResp.Validate if the designated constraints aren't met.
type MediaDataListRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MediaDataListRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MediaDataListRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MediaDataListRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MediaDataListRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MediaDataListRespValidationError) ErrorName() string {
	return "MediaDataListRespValidationError"
}

// Error satisfies the builtin error interface
func (e MediaDataListRespValidationError) 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 %sMediaDataListResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaDataListRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MediaDataListRespValidationError{}

// Validate checks the field values on DataOverviewReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *DataOverviewReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DataOverviewReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// DataOverviewReqMultiError, or nil if none found.
func (m *DataOverviewReq) ValidateAll() error {
	return m.validate(true)
}

func (m *DataOverviewReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Date

	if len(errors) > 0 {
		return DataOverviewReqMultiError(errors)
	}

	return nil
}

// DataOverviewReqMultiError is an error wrapping multiple validation errors
// returned by DataOverviewReq.ValidateAll() if the designated constraints
// aren't met.
type DataOverviewReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m DataOverviewReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m DataOverviewReqMultiError) AllErrors() []error { return m }

// DataOverviewReqValidationError is the validation error returned by
// DataOverviewReq.Validate if the designated constraints aren't met.
type DataOverviewReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e DataOverviewReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e DataOverviewReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e DataOverviewReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e DataOverviewReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e DataOverviewReqValidationError) ErrorName() string { return "DataOverviewReqValidationError" }

// Error satisfies the builtin error interface
func (e DataOverviewReqValidationError) 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 %sDataOverviewReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DataOverviewReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = DataOverviewReqValidationError{}

// Validate checks the field values on DataOverviewResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *DataOverviewResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DataOverviewResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// DataOverviewRespMultiError, or nil if none found.
func (m *DataOverviewResp) ValidateAll() error {
	return m.validate(true)
}

func (m *DataOverviewResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for AccountCount

	// no validation rules for TodayAccountCount

	// no validation rules for FansCount

	// no validation rules for TodayFansCount

	// no validation rules for ViewsCount

	// no validation rules for TodayViewsCount

	// no validation rules for LikesCount

	// no validation rules for TodayLikesCount

	// no validation rules for CommentsCount

	// no validation rules for TodayCommentsCount

	// no validation rules for SharesCount

	// no validation rules for TodaySharesCount

	// no validation rules for ImageCount

	// no validation rules for TodayImageCount

	// no validation rules for VideoCount

	// no validation rules for TodayVideoCount

	// no validation rules for ConfirmDataCount

	// no validation rules for TodayConfirmDataCount

	// no validation rules for ToBeConfirmedDataCount

	// no validation rules for ApprovingDataCount

	if len(errors) > 0 {
		return DataOverviewRespMultiError(errors)
	}

	return nil
}

// DataOverviewRespMultiError is an error wrapping multiple validation errors
// returned by DataOverviewResp.ValidateAll() if the designated constraints
// aren't met.
type DataOverviewRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m DataOverviewRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m DataOverviewRespMultiError) AllErrors() []error { return m }

// DataOverviewRespValidationError is the validation error returned by
// DataOverviewResp.Validate if the designated constraints aren't met.
type DataOverviewRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e DataOverviewRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e DataOverviewRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e DataOverviewRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e DataOverviewRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e DataOverviewRespValidationError) ErrorName() string { return "DataOverviewRespValidationError" }

// Error satisfies the builtin error interface
func (e DataOverviewRespValidationError) 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 %sDataOverviewResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DataOverviewRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = DataOverviewRespValidationError{}

// Validate checks the field values on ArtistMetricsSeriesReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ArtistMetricsSeriesReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistMetricsSeriesReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ArtistMetricsSeriesReqMultiError, or nil if none found.
func (m *ArtistMetricsSeriesReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistMetricsSeriesReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUUID

	// no validation rules for PeriodTypeFans

	// no validation rules for PeriodTypeViews

	// no validation rules for PeriodTypeLikes

	// no validation rules for PeriodTypeComments

	// no validation rules for PeriodTypeShares

	// no validation rules for Date

	if len(errors) > 0 {
		return ArtistMetricsSeriesReqMultiError(errors)
	}

	return nil
}

// ArtistMetricsSeriesReqMultiError is an error wrapping multiple validation
// errors returned by ArtistMetricsSeriesReq.ValidateAll() if the designated
// constraints aren't met.
type ArtistMetricsSeriesReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistMetricsSeriesReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistMetricsSeriesReqMultiError) AllErrors() []error { return m }

// ArtistMetricsSeriesReqValidationError is the validation error returned by
// ArtistMetricsSeriesReq.Validate if the designated constraints aren't met.
type ArtistMetricsSeriesReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ArtistMetricsSeriesReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ArtistMetricsSeriesReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ArtistMetricsSeriesReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ArtistMetricsSeriesReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ArtistMetricsSeriesReqValidationError) ErrorName() string {
	return "ArtistMetricsSeriesReqValidationError"
}

// Error satisfies the builtin error interface
func (e ArtistMetricsSeriesReqValidationError) 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 %sArtistMetricsSeriesReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistMetricsSeriesReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ArtistMetricsSeriesReqValidationError{}

// Validate checks the field values on ArtistMetricsSeriesResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ArtistMetricsSeriesResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistMetricsSeriesResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ArtistMetricsSeriesRespMultiError, or nil if none found.
func (m *ArtistMetricsSeriesResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistMetricsSeriesResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if all {
		switch v := interface{}(m.GetFansSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "FansSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "FansSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetFansSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return ArtistMetricsSeriesRespValidationError{
				field:  "FansSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetViewsSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "ViewsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "ViewsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetViewsSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return ArtistMetricsSeriesRespValidationError{
				field:  "ViewsSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetLikesSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "LikesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "LikesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetLikesSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return ArtistMetricsSeriesRespValidationError{
				field:  "LikesSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetCommentsSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "CommentsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "CommentsSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetCommentsSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return ArtistMetricsSeriesRespValidationError{
				field:  "CommentsSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetSharesSeries()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "SharesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "SharesSeries",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetSharesSeries()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return ArtistMetricsSeriesRespValidationError{
				field:  "SharesSeries",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetBestPostTime()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "BestPostTime",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "BestPostTime",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetBestPostTime()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return ArtistMetricsSeriesRespValidationError{
				field:  "BestPostTime",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if all {
		switch v := interface{}(m.GetMostActiveDay()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "MostActiveDay",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, ArtistMetricsSeriesRespValidationError{
					field:  "MostActiveDay",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetMostActiveDay()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return ArtistMetricsSeriesRespValidationError{
				field:  "MostActiveDay",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if len(errors) > 0 {
		return ArtistMetricsSeriesRespMultiError(errors)
	}

	return nil
}

// ArtistMetricsSeriesRespMultiError is an error wrapping multiple validation
// errors returned by ArtistMetricsSeriesResp.ValidateAll() if the designated
// constraints aren't met.
type ArtistMetricsSeriesRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistMetricsSeriesRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistMetricsSeriesRespMultiError) AllErrors() []error { return m }

// ArtistMetricsSeriesRespValidationError is the validation error returned by
// ArtistMetricsSeriesResp.Validate if the designated constraints aren't met.
type ArtistMetricsSeriesRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ArtistMetricsSeriesRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ArtistMetricsSeriesRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ArtistMetricsSeriesRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ArtistMetricsSeriesRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ArtistMetricsSeriesRespValidationError) ErrorName() string {
	return "ArtistMetricsSeriesRespValidationError"
}

// Error satisfies the builtin error interface
func (e ArtistMetricsSeriesRespValidationError) 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 %sArtistMetricsSeriesResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistMetricsSeriesRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ArtistMetricsSeriesRespValidationError{}

// Validate checks the field values on ArtistMetricsDailyWindowReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ArtistMetricsDailyWindowReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistMetricsDailyWindowReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ArtistMetricsDailyWindowReqMultiError, or nil if none found.
func (m *ArtistMetricsDailyWindowReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistMetricsDailyWindowReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUUID

	// no validation rules for PlatformID

	// no validation rules for Date

	if len(errors) > 0 {
		return ArtistMetricsDailyWindowReqMultiError(errors)
	}

	return nil
}

// ArtistMetricsDailyWindowReqMultiError is an error wrapping multiple
// validation errors returned by ArtistMetricsDailyWindowReq.ValidateAll() if
// the designated constraints aren't met.
type ArtistMetricsDailyWindowReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistMetricsDailyWindowReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistMetricsDailyWindowReqMultiError) AllErrors() []error { return m }

// ArtistMetricsDailyWindowReqValidationError is the validation error returned
// by ArtistMetricsDailyWindowReq.Validate if the designated constraints
// aren't met.
type ArtistMetricsDailyWindowReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ArtistMetricsDailyWindowReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ArtistMetricsDailyWindowReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ArtistMetricsDailyWindowReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ArtistMetricsDailyWindowReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ArtistMetricsDailyWindowReqValidationError) ErrorName() string {
	return "ArtistMetricsDailyWindowReqValidationError"
}

// Error satisfies the builtin error interface
func (e ArtistMetricsDailyWindowReqValidationError) 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 %sArtistMetricsDailyWindowReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistMetricsDailyWindowReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ArtistMetricsDailyWindowReqValidationError{}

// Validate checks the field values on SimplePoint with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *SimplePoint) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SimplePoint with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in SimplePointMultiError, or
// nil if none found.
func (m *SimplePoint) ValidateAll() error {
	return m.validate(true)
}

func (m *SimplePoint) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Date

	// no validation rules for Value

	if len(errors) > 0 {
		return SimplePointMultiError(errors)
	}

	return nil
}

// SimplePointMultiError is an error wrapping multiple validation errors
// returned by SimplePoint.ValidateAll() if the designated constraints aren't met.
type SimplePointMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m SimplePointMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m SimplePointMultiError) AllErrors() []error { return m }

// SimplePointValidationError is the validation error returned by
// SimplePoint.Validate if the designated constraints aren't met.
type SimplePointValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SimplePointValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SimplePointValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SimplePointValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SimplePointValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SimplePointValidationError) ErrorName() string { return "SimplePointValidationError" }

// Error satisfies the builtin error interface
func (e SimplePointValidationError) 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 %sSimplePoint.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SimplePointValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SimplePointValidationError{}

// Validate checks the field values on BestPostTimePoint with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *BestPostTimePoint) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on BestPostTimePoint with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// BestPostTimePointMultiError, or nil if none found.
func (m *BestPostTimePoint) ValidateAll() error {
	return m.validate(true)
}

func (m *BestPostTimePoint) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for TimePoint

	// no validation rules for Value

	if len(errors) > 0 {
		return BestPostTimePointMultiError(errors)
	}

	return nil
}

// BestPostTimePointMultiError is an error wrapping multiple validation errors
// returned by BestPostTimePoint.ValidateAll() if the designated constraints
// aren't met.
type BestPostTimePointMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m BestPostTimePointMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m BestPostTimePointMultiError) AllErrors() []error { return m }

// BestPostTimePointValidationError is the validation error returned by
// BestPostTimePoint.Validate if the designated constraints aren't met.
type BestPostTimePointValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e BestPostTimePointValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e BestPostTimePointValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e BestPostTimePointValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e BestPostTimePointValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e BestPostTimePointValidationError) ErrorName() string {
	return "BestPostTimePointValidationError"
}

// Error satisfies the builtin error interface
func (e BestPostTimePointValidationError) 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 %sBestPostTimePoint.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = BestPostTimePointValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = BestPostTimePointValidationError{}

// Validate checks the field values on MostActiveDayPoint with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *MostActiveDayPoint) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MostActiveDayPoint with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MostActiveDayPointMultiError, or nil if none found.
func (m *MostActiveDayPoint) ValidateAll() error {
	return m.validate(true)
}

func (m *MostActiveDayPoint) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Day

	// no validation rules for Value

	if len(errors) > 0 {
		return MostActiveDayPointMultiError(errors)
	}

	return nil
}

// MostActiveDayPointMultiError is an error wrapping multiple validation errors
// returned by MostActiveDayPoint.ValidateAll() if the designated constraints
// aren't met.
type MostActiveDayPointMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MostActiveDayPointMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MostActiveDayPointMultiError) AllErrors() []error { return m }

// MostActiveDayPointValidationError is the validation error returned by
// MostActiveDayPoint.Validate if the designated constraints aren't met.
type MostActiveDayPointValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MostActiveDayPointValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MostActiveDayPointValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MostActiveDayPointValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MostActiveDayPointValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MostActiveDayPointValidationError) ErrorName() string {
	return "MostActiveDayPointValidationError"
}

// Error satisfies the builtin error interface
func (e MostActiveDayPointValidationError) 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 %sMostActiveDayPoint.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MostActiveDayPointValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MostActiveDayPointValidationError{}

// Validate checks the field values on ArtistMetricsDailyWindowResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ArtistMetricsDailyWindowResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistMetricsDailyWindowResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ArtistMetricsDailyWindowRespMultiError, or nil if none found.
func (m *ArtistMetricsDailyWindowResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistMetricsDailyWindowResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for FansCount

	// no validation rules for ViewsCount

	// no validation rules for LikesCount

	// no validation rules for CommentsCount

	// no validation rules for SharesCount

	for idx, item := range m.GetFans() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Fans[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Fans[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ArtistMetricsDailyWindowRespValidationError{
					field:  fmt.Sprintf("Fans[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	for idx, item := range m.GetViews() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Views[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Views[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ArtistMetricsDailyWindowRespValidationError{
					field:  fmt.Sprintf("Views[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	for idx, item := range m.GetLikes() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Likes[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Likes[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ArtistMetricsDailyWindowRespValidationError{
					field:  fmt.Sprintf("Likes[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	for idx, item := range m.GetComments() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Comments[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Comments[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ArtistMetricsDailyWindowRespValidationError{
					field:  fmt.Sprintf("Comments[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	for idx, item := range m.GetShares() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Shares[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("Shares[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ArtistMetricsDailyWindowRespValidationError{
					field:  fmt.Sprintf("Shares[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	for idx, item := range m.GetBestPostTime() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("BestPostTime[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("BestPostTime[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ArtistMetricsDailyWindowRespValidationError{
					field:  fmt.Sprintf("BestPostTime[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	for idx, item := range m.GetMostActiveDay() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("MostActiveDay[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ArtistMetricsDailyWindowRespValidationError{
						field:  fmt.Sprintf("MostActiveDay[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ArtistMetricsDailyWindowRespValidationError{
					field:  fmt.Sprintf("MostActiveDay[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return ArtistMetricsDailyWindowRespMultiError(errors)
	}

	return nil
}

// ArtistMetricsDailyWindowRespMultiError is an error wrapping multiple
// validation errors returned by ArtistMetricsDailyWindowResp.ValidateAll() if
// the designated constraints aren't met.
type ArtistMetricsDailyWindowRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistMetricsDailyWindowRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistMetricsDailyWindowRespMultiError) AllErrors() []error { return m }

// ArtistMetricsDailyWindowRespValidationError is the validation error returned
// by ArtistMetricsDailyWindowResp.Validate if the designated constraints
// aren't met.
type ArtistMetricsDailyWindowRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ArtistMetricsDailyWindowRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ArtistMetricsDailyWindowRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ArtistMetricsDailyWindowRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ArtistMetricsDailyWindowRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ArtistMetricsDailyWindowRespValidationError) ErrorName() string {
	return "ArtistMetricsDailyWindowRespValidationError"
}

// Error satisfies the builtin error interface
func (e ArtistMetricsDailyWindowRespValidationError) 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 %sArtistMetricsDailyWindowResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistMetricsDailyWindowRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ArtistMetricsDailyWindowRespValidationError{}

// Validate checks the field values on TobeConfirmedListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *TobeConfirmedListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on TobeConfirmedListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// TobeConfirmedListReqMultiError, or nil if none found.
func (m *TobeConfirmedListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *TobeConfirmedListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for StartAt

	// no validation rules for ExpiredAt

	if len(errors) > 0 {
		return TobeConfirmedListReqMultiError(errors)
	}

	return nil
}

// TobeConfirmedListReqMultiError is an error wrapping multiple validation
// errors returned by TobeConfirmedListReq.ValidateAll() if the designated
// constraints aren't met.
type TobeConfirmedListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m TobeConfirmedListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m TobeConfirmedListReqMultiError) AllErrors() []error { return m }

// TobeConfirmedListReqValidationError is the validation error returned by
// TobeConfirmedListReq.Validate if the designated constraints aren't met.
type TobeConfirmedListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e TobeConfirmedListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e TobeConfirmedListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e TobeConfirmedListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e TobeConfirmedListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e TobeConfirmedListReqValidationError) ErrorName() string {
	return "TobeConfirmedListReqValidationError"
}

// Error satisfies the builtin error interface
func (e TobeConfirmedListReqValidationError) 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 %sTobeConfirmedListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = TobeConfirmedListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = TobeConfirmedListReqValidationError{}

// Validate checks the field values on TobeConfirmedItem with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *TobeConfirmedItem) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on TobeConfirmedItem with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// TobeConfirmedItemMultiError, or nil if none found.
func (m *TobeConfirmedItem) ValidateAll() error {
	return m.validate(true)
}

func (m *TobeConfirmedItem) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Title

	// no validation rules for Content

	// no validation rules for WorkCategory

	// no validation rules for UpdateTime

	// no validation rules for WorkStatus

	// no validation rules for PlatformIds

	// no validation rules for ArtistName

	// no validation rules for ArtistUuid

	// no validation rules for MediaAccUserIds

	// no validation rules for MediaNames

	// no validation rules for ConfirmedAt

	// no validation rules for ItemType

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	// no validation rules for DeletedAt

	if len(errors) > 0 {
		return TobeConfirmedItemMultiError(errors)
	}

	return nil
}

// TobeConfirmedItemMultiError is an error wrapping multiple validation errors
// returned by TobeConfirmedItem.ValidateAll() if the designated constraints
// aren't met.
type TobeConfirmedItemMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m TobeConfirmedItemMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m TobeConfirmedItemMultiError) AllErrors() []error { return m }

// TobeConfirmedItemValidationError is the validation error returned by
// TobeConfirmedItem.Validate if the designated constraints aren't met.
type TobeConfirmedItemValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e TobeConfirmedItemValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e TobeConfirmedItemValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e TobeConfirmedItemValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e TobeConfirmedItemValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e TobeConfirmedItemValidationError) ErrorName() string {
	return "TobeConfirmedItemValidationError"
}

// Error satisfies the builtin error interface
func (e TobeConfirmedItemValidationError) 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 %sTobeConfirmedItem.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = TobeConfirmedItemValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = TobeConfirmedItemValidationError{}

// Validate checks the field values on TobeConfirmedListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *TobeConfirmedListResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on TobeConfirmedListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// TobeConfirmedListRespMultiError, or nil if none found.
func (m *TobeConfirmedListResp) ValidateAll() error {
	return m.validate(true)
}

func (m *TobeConfirmedListResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, TobeConfirmedListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, TobeConfirmedListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return TobeConfirmedListRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return TobeConfirmedListRespMultiError(errors)
	}

	return nil
}

// TobeConfirmedListRespMultiError is an error wrapping multiple validation
// errors returned by TobeConfirmedListResp.ValidateAll() if the designated
// constraints aren't met.
type TobeConfirmedListRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m TobeConfirmedListRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m TobeConfirmedListRespMultiError) AllErrors() []error { return m }

// TobeConfirmedListRespValidationError is the validation error returned by
// TobeConfirmedListResp.Validate if the designated constraints aren't met.
type TobeConfirmedListRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e TobeConfirmedListRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e TobeConfirmedListRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e TobeConfirmedListRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e TobeConfirmedListRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e TobeConfirmedListRespValidationError) ErrorName() string {
	return "TobeConfirmedListRespValidationError"
}

// Error satisfies the builtin error interface
func (e TobeConfirmedListRespValidationError) 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 %sTobeConfirmedListResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = TobeConfirmedListRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = TobeConfirmedListRespValidationError{}

// Validate checks the field values on UpdateWorkAnalysisApprovalIDReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkAnalysisApprovalIDReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkAnalysisApprovalIDReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// UpdateWorkAnalysisApprovalIDReqMultiError, or nil if none found.
func (m *UpdateWorkAnalysisApprovalIDReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkAnalysisApprovalIDReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for ApprovalID

	if len(errors) > 0 {
		return UpdateWorkAnalysisApprovalIDReqMultiError(errors)
	}

	return nil
}

// UpdateWorkAnalysisApprovalIDReqMultiError is an error wrapping multiple
// validation errors returned by UpdateWorkAnalysisApprovalIDReq.ValidateAll()
// if the designated constraints aren't met.
type UpdateWorkAnalysisApprovalIDReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkAnalysisApprovalIDReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkAnalysisApprovalIDReqMultiError) AllErrors() []error { return m }

// UpdateWorkAnalysisApprovalIDReqValidationError is the validation error
// returned by UpdateWorkAnalysisApprovalIDReq.Validate if the designated
// constraints aren't met.
type UpdateWorkAnalysisApprovalIDReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateWorkAnalysisApprovalIDReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateWorkAnalysisApprovalIDReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateWorkAnalysisApprovalIDReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateWorkAnalysisApprovalIDReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateWorkAnalysisApprovalIDReqValidationError) ErrorName() string {
	return "UpdateWorkAnalysisApprovalIDReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateWorkAnalysisApprovalIDReqValidationError) 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 %sUpdateWorkAnalysisApprovalIDReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkAnalysisApprovalIDReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateWorkAnalysisApprovalIDReqValidationError{}

// Validate checks the field values on MediaMetricsDailyItem with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *MediaMetricsDailyItem) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaMetricsDailyItem with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaMetricsDailyItemMultiError, or nil if none found.
func (m *MediaMetricsDailyItem) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaMetricsDailyItem) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for ArtistUuid

	// no validation rules for MediaAccUserID

	// no validation rules for MediaName

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for PlatformID

	// no validation rules for Date

	// no validation rules for FansCount

	// no validation rules for ViewsCount

	// no validation rules for LikesCount

	// no validation rules for CommentsCount

	// no validation rules for SharesCount

	// no validation rules for VideoCount

	// no validation rules for ImageCount

	// no validation rules for ProfileKey

	// no validation rules for IsSuccess

	// no validation rules for FailReason

	// no validation rules for FailType

	if len(errors) > 0 {
		return MediaMetricsDailyItemMultiError(errors)
	}

	return nil
}

// MediaMetricsDailyItemMultiError is an error wrapping multiple validation
// errors returned by MediaMetricsDailyItem.ValidateAll() if the designated
// constraints aren't met.
type MediaMetricsDailyItemMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaMetricsDailyItemMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaMetricsDailyItemMultiError) AllErrors() []error { return m }

// MediaMetricsDailyItemValidationError is the validation error returned by
// MediaMetricsDailyItem.Validate if the designated constraints aren't met.
type MediaMetricsDailyItemValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MediaMetricsDailyItemValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MediaMetricsDailyItemValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MediaMetricsDailyItemValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MediaMetricsDailyItemValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MediaMetricsDailyItemValidationError) ErrorName() string {
	return "MediaMetricsDailyItemValidationError"
}

// Error satisfies the builtin error interface
func (e MediaMetricsDailyItemValidationError) 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 %sMediaMetricsDailyItem.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaMetricsDailyItemValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MediaMetricsDailyItemValidationError{}

// Validate checks the field values on UpsertMediaMetricsDailyBatchReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpsertMediaMetricsDailyBatchReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpsertMediaMetricsDailyBatchReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// UpsertMediaMetricsDailyBatchReqMultiError, or nil if none found.
func (m *UpsertMediaMetricsDailyBatchReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpsertMediaMetricsDailyBatchReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpsertMediaMetricsDailyBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpsertMediaMetricsDailyBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpsertMediaMetricsDailyBatchReqValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return UpsertMediaMetricsDailyBatchReqMultiError(errors)
	}

	return nil
}

// UpsertMediaMetricsDailyBatchReqMultiError is an error wrapping multiple
// validation errors returned by UpsertMediaMetricsDailyBatchReq.ValidateAll()
// if the designated constraints aren't met.
type UpsertMediaMetricsDailyBatchReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpsertMediaMetricsDailyBatchReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpsertMediaMetricsDailyBatchReqMultiError) AllErrors() []error { return m }

// UpsertMediaMetricsDailyBatchReqValidationError is the validation error
// returned by UpsertMediaMetricsDailyBatchReq.Validate if the designated
// constraints aren't met.
type UpsertMediaMetricsDailyBatchReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpsertMediaMetricsDailyBatchReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpsertMediaMetricsDailyBatchReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpsertMediaMetricsDailyBatchReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpsertMediaMetricsDailyBatchReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpsertMediaMetricsDailyBatchReqValidationError) ErrorName() string {
	return "UpsertMediaMetricsDailyBatchReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpsertMediaMetricsDailyBatchReqValidationError) 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 %sUpsertMediaMetricsDailyBatchReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpsertMediaMetricsDailyBatchReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpsertMediaMetricsDailyBatchReqValidationError{}

// Validate checks the field values on UpsertMediaMetricsDailyBatchResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the first error encountered is returned, or nil if there are
// no violations.
func (m *UpsertMediaMetricsDailyBatchResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpsertMediaMetricsDailyBatchResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// UpsertMediaMetricsDailyBatchRespMultiError, or nil if none found.
func (m *UpsertMediaMetricsDailyBatchResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpsertMediaMetricsDailyBatchResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Success

	if len(errors) > 0 {
		return UpsertMediaMetricsDailyBatchRespMultiError(errors)
	}

	return nil
}

// UpsertMediaMetricsDailyBatchRespMultiError is an error wrapping multiple
// validation errors returned by
// UpsertMediaMetricsDailyBatchResp.ValidateAll() if the designated
// constraints aren't met.
type UpsertMediaMetricsDailyBatchRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpsertMediaMetricsDailyBatchRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpsertMediaMetricsDailyBatchRespMultiError) AllErrors() []error { return m }

// UpsertMediaMetricsDailyBatchRespValidationError is the validation error
// returned by UpsertMediaMetricsDailyBatchResp.Validate if the designated
// constraints aren't met.
type UpsertMediaMetricsDailyBatchRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpsertMediaMetricsDailyBatchRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpsertMediaMetricsDailyBatchRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpsertMediaMetricsDailyBatchRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpsertMediaMetricsDailyBatchRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpsertMediaMetricsDailyBatchRespValidationError) ErrorName() string {
	return "UpsertMediaMetricsDailyBatchRespValidationError"
}

// Error satisfies the builtin error interface
func (e UpsertMediaMetricsDailyBatchRespValidationError) 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 %sUpsertMediaMetricsDailyBatchResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpsertMediaMetricsDailyBatchRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpsertMediaMetricsDailyBatchRespValidationError{}

// Validate checks the field values on WorkMetricsDailyItem with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkMetricsDailyItem) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkMetricsDailyItem with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkMetricsDailyItemMultiError, or nil if none found.
func (m *WorkMetricsDailyItem) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkMetricsDailyItem) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for WorkUuid

	// no validation rules for ArtistUuid

	// no validation rules for MediaAccUserID

	// no validation rules for MediaName

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for PlatformID

	// no validation rules for Date

	// no validation rules for ViewsCount

	// no validation rules for LikesCount

	// no validation rules for CommentsCount

	// no validation rules for SharesCount

	// no validation rules for PublishMediaID

	// no validation rules for ProfileKey

	// no validation rules for IsSuccess

	// no validation rules for FailReason

	// no validation rules for FailType

	if len(errors) > 0 {
		return WorkMetricsDailyItemMultiError(errors)
	}

	return nil
}

// WorkMetricsDailyItemMultiError is an error wrapping multiple validation
// errors returned by WorkMetricsDailyItem.ValidateAll() if the designated
// constraints aren't met.
type WorkMetricsDailyItemMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkMetricsDailyItemMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkMetricsDailyItemMultiError) AllErrors() []error { return m }

// WorkMetricsDailyItemValidationError is the validation error returned by
// WorkMetricsDailyItem.Validate if the designated constraints aren't met.
type WorkMetricsDailyItemValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e WorkMetricsDailyItemValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e WorkMetricsDailyItemValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e WorkMetricsDailyItemValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e WorkMetricsDailyItemValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e WorkMetricsDailyItemValidationError) ErrorName() string {
	return "WorkMetricsDailyItemValidationError"
}

// Error satisfies the builtin error interface
func (e WorkMetricsDailyItemValidationError) 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 %sWorkMetricsDailyItem.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkMetricsDailyItemValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = WorkMetricsDailyItemValidationError{}

// Validate checks the field values on UpsertWorkMetricsDailyBatchReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpsertWorkMetricsDailyBatchReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpsertWorkMetricsDailyBatchReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// UpsertWorkMetricsDailyBatchReqMultiError, or nil if none found.
func (m *UpsertWorkMetricsDailyBatchReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpsertWorkMetricsDailyBatchReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpsertWorkMetricsDailyBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpsertWorkMetricsDailyBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpsertWorkMetricsDailyBatchReqValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return UpsertWorkMetricsDailyBatchReqMultiError(errors)
	}

	return nil
}

// UpsertWorkMetricsDailyBatchReqMultiError is an error wrapping multiple
// validation errors returned by UpsertWorkMetricsDailyBatchReq.ValidateAll()
// if the designated constraints aren't met.
type UpsertWorkMetricsDailyBatchReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpsertWorkMetricsDailyBatchReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpsertWorkMetricsDailyBatchReqMultiError) AllErrors() []error { return m }

// UpsertWorkMetricsDailyBatchReqValidationError is the validation error
// returned by UpsertWorkMetricsDailyBatchReq.Validate if the designated
// constraints aren't met.
type UpsertWorkMetricsDailyBatchReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpsertWorkMetricsDailyBatchReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpsertWorkMetricsDailyBatchReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpsertWorkMetricsDailyBatchReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpsertWorkMetricsDailyBatchReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpsertWorkMetricsDailyBatchReqValidationError) ErrorName() string {
	return "UpsertWorkMetricsDailyBatchReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpsertWorkMetricsDailyBatchReqValidationError) 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 %sUpsertWorkMetricsDailyBatchReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpsertWorkMetricsDailyBatchReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpsertWorkMetricsDailyBatchReqValidationError{}

// Validate checks the field values on UpsertWorkMetricsDailyBatchResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpsertWorkMetricsDailyBatchResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpsertWorkMetricsDailyBatchResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// UpsertWorkMetricsDailyBatchRespMultiError, or nil if none found.
func (m *UpsertWorkMetricsDailyBatchResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpsertWorkMetricsDailyBatchResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Success

	if len(errors) > 0 {
		return UpsertWorkMetricsDailyBatchRespMultiError(errors)
	}

	return nil
}

// UpsertWorkMetricsDailyBatchRespMultiError is an error wrapping multiple
// validation errors returned by UpsertWorkMetricsDailyBatchResp.ValidateAll()
// if the designated constraints aren't met.
type UpsertWorkMetricsDailyBatchRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpsertWorkMetricsDailyBatchRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpsertWorkMetricsDailyBatchRespMultiError) AllErrors() []error { return m }

// UpsertWorkMetricsDailyBatchRespValidationError is the validation error
// returned by UpsertWorkMetricsDailyBatchResp.Validate if the designated
// constraints aren't met.
type UpsertWorkMetricsDailyBatchRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpsertWorkMetricsDailyBatchRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpsertWorkMetricsDailyBatchRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpsertWorkMetricsDailyBatchRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpsertWorkMetricsDailyBatchRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpsertWorkMetricsDailyBatchRespValidationError) ErrorName() string {
	return "UpsertWorkMetricsDailyBatchRespValidationError"
}

// Error satisfies the builtin error interface
func (e UpsertWorkMetricsDailyBatchRespValidationError) 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 %sUpsertWorkMetricsDailyBatchResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpsertWorkMetricsDailyBatchRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpsertWorkMetricsDailyBatchRespValidationError{}

// Validate checks the field values on GetArtistAyrShareInfoReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetArtistAyrShareInfoReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetArtistAyrShareInfoReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetArtistAyrShareInfoReqMultiError, or nil if none found.
func (m *GetArtistAyrShareInfoReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetArtistAyrShareInfoReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for SubNum

	// no validation rules for Status

	// no validation rules for Page

	// no validation rules for PageSize

	if len(errors) > 0 {
		return GetArtistAyrShareInfoReqMultiError(errors)
	}

	return nil
}

// GetArtistAyrShareInfoReqMultiError is an error wrapping multiple validation
// errors returned by GetArtistAyrShareInfoReq.ValidateAll() if the designated
// constraints aren't met.
type GetArtistAyrShareInfoReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetArtistAyrShareInfoReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetArtistAyrShareInfoReqMultiError) AllErrors() []error { return m }

// GetArtistAyrShareInfoReqValidationError is the validation error returned by
// GetArtistAyrShareInfoReq.Validate if the designated constraints aren't met.
type GetArtistAyrShareInfoReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetArtistAyrShareInfoReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetArtistAyrShareInfoReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetArtistAyrShareInfoReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetArtistAyrShareInfoReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetArtistAyrShareInfoReqValidationError) ErrorName() string {
	return "GetArtistAyrShareInfoReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetArtistAyrShareInfoReqValidationError) 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 %sGetArtistAyrShareInfoReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetArtistAyrShareInfoReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetArtistAyrShareInfoReqValidationError{}

// Validate checks the field values on ArtistAyrShareInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ArtistAyrShareInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ArtistAyrShareInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ArtistAyrShareInfoMultiError, or nil if none found.
func (m *ArtistAyrShareInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *ArtistAyrShareInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for ArtistUuid

	// no validation rules for SubNum

	// no validation rules for RefId

	// no validation rules for ProfileKey

	// no validation rules for AyrShareCreateTime

	// no validation rules for Status

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return ArtistAyrShareInfoMultiError(errors)
	}

	return nil
}

// ArtistAyrShareInfoMultiError is an error wrapping multiple validation errors
// returned by ArtistAyrShareInfo.ValidateAll() if the designated constraints
// aren't met.
type ArtistAyrShareInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ArtistAyrShareInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ArtistAyrShareInfoMultiError) AllErrors() []error { return m }

// ArtistAyrShareInfoValidationError is the validation error returned by
// ArtistAyrShareInfo.Validate if the designated constraints aren't met.
type ArtistAyrShareInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ArtistAyrShareInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ArtistAyrShareInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ArtistAyrShareInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ArtistAyrShareInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ArtistAyrShareInfoValidationError) ErrorName() string {
	return "ArtistAyrShareInfoValidationError"
}

// Error satisfies the builtin error interface
func (e ArtistAyrShareInfoValidationError) 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 %sArtistAyrShareInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ArtistAyrShareInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ArtistAyrShareInfoValidationError{}

// Validate checks the field values on GetArtistAyrShareInfoResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetArtistAyrShareInfoResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetArtistAyrShareInfoResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetArtistAyrShareInfoRespMultiError, or nil if none found.
func (m *GetArtistAyrShareInfoResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetArtistAyrShareInfoResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetArtistAyrShareInfoRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetArtistAyrShareInfoRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetArtistAyrShareInfoRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return GetArtistAyrShareInfoRespMultiError(errors)
	}

	return nil
}

// GetArtistAyrShareInfoRespMultiError is an error wrapping multiple validation
// errors returned by GetArtistAyrShareInfoResp.ValidateAll() if the
// designated constraints aren't met.
type GetArtistAyrShareInfoRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetArtistAyrShareInfoRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetArtistAyrShareInfoRespMultiError) AllErrors() []error { return m }

// GetArtistAyrShareInfoRespValidationError is the validation error returned by
// GetArtistAyrShareInfoResp.Validate if the designated constraints aren't met.
type GetArtistAyrShareInfoRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetArtistAyrShareInfoRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetArtistAyrShareInfoRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetArtistAyrShareInfoRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetArtistAyrShareInfoRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetArtistAyrShareInfoRespValidationError) ErrorName() string {
	return "GetArtistAyrShareInfoRespValidationError"
}

// Error satisfies the builtin error interface
func (e GetArtistAyrShareInfoRespValidationError) 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 %sGetArtistAyrShareInfoResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetArtistAyrShareInfoRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetArtistAyrShareInfoRespValidationError{}

// Validate checks the field values on GetArtistAyrShareInfoByPlatformIDsReq
// with the rules defined in the proto definition for this message. If any
// rules are violated, the first error encountered is returned, or nil if
// there are no violations.
func (m *GetArtistAyrShareInfoByPlatformIDsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetArtistAyrShareInfoByPlatformIDsReq
// with the rules defined in the proto definition for this message. If any
// rules are violated, the result is a list of violation errors wrapped in
// GetArtistAyrShareInfoByPlatformIDsReqMultiError, or nil if none found.
func (m *GetArtistAyrShareInfoByPlatformIDsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetArtistAyrShareInfoByPlatformIDsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Page

	// no validation rules for PageSize

	if len(errors) > 0 {
		return GetArtistAyrShareInfoByPlatformIDsReqMultiError(errors)
	}

	return nil
}

// GetArtistAyrShareInfoByPlatformIDsReqMultiError is an error wrapping
// multiple validation errors returned by
// GetArtistAyrShareInfoByPlatformIDsReq.ValidateAll() if the designated
// constraints aren't met.
type GetArtistAyrShareInfoByPlatformIDsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetArtistAyrShareInfoByPlatformIDsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetArtistAyrShareInfoByPlatformIDsReqMultiError) AllErrors() []error { return m }

// GetArtistAyrShareInfoByPlatformIDsReqValidationError is the validation error
// returned by GetArtistAyrShareInfoByPlatformIDsReq.Validate if the
// designated constraints aren't met.
type GetArtistAyrShareInfoByPlatformIDsReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetArtistAyrShareInfoByPlatformIDsReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetArtistAyrShareInfoByPlatformIDsReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetArtistAyrShareInfoByPlatformIDsReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetArtistAyrShareInfoByPlatformIDsReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetArtistAyrShareInfoByPlatformIDsReqValidationError) ErrorName() string {
	return "GetArtistAyrShareInfoByPlatformIDsReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetArtistAyrShareInfoByPlatformIDsReqValidationError) 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 %sGetArtistAyrShareInfoByPlatformIDsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetArtistAyrShareInfoByPlatformIDsReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetArtistAyrShareInfoByPlatformIDsReqValidationError{}

// Validate checks the field values on GetArtistAyrShareInfoByPlatformIDsResp
// with the rules defined in the proto definition for this message. If any
// rules are violated, the first error encountered is returned, or nil if
// there are no violations.
func (m *GetArtistAyrShareInfoByPlatformIDsResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on
// GetArtistAyrShareInfoByPlatformIDsResp with the rules defined in the proto
// definition for this message. If any rules are violated, the result is a
// list of violation errors wrapped in
// GetArtistAyrShareInfoByPlatformIDsRespMultiError, or nil if none found.
func (m *GetArtistAyrShareInfoByPlatformIDsResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetArtistAyrShareInfoByPlatformIDsResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetArtistAyrShareInfoByPlatformIDsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetArtistAyrShareInfoByPlatformIDsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetArtistAyrShareInfoByPlatformIDsRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return GetArtistAyrShareInfoByPlatformIDsRespMultiError(errors)
	}

	return nil
}

// GetArtistAyrShareInfoByPlatformIDsRespMultiError is an error wrapping
// multiple validation errors returned by
// GetArtistAyrShareInfoByPlatformIDsResp.ValidateAll() if the designated
// constraints aren't met.
type GetArtistAyrShareInfoByPlatformIDsRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetArtistAyrShareInfoByPlatformIDsRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetArtistAyrShareInfoByPlatformIDsRespMultiError) AllErrors() []error { return m }

// GetArtistAyrShareInfoByPlatformIDsRespValidationError is the validation
// error returned by GetArtistAyrShareInfoByPlatformIDsResp.Validate if the
// designated constraints aren't met.
type GetArtistAyrShareInfoByPlatformIDsRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetArtistAyrShareInfoByPlatformIDsRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetArtistAyrShareInfoByPlatformIDsRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetArtistAyrShareInfoByPlatformIDsRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetArtistAyrShareInfoByPlatformIDsRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetArtistAyrShareInfoByPlatformIDsRespValidationError) ErrorName() string {
	return "GetArtistAyrShareInfoByPlatformIDsRespValidationError"
}

// Error satisfies the builtin error interface
func (e GetArtistAyrShareInfoByPlatformIDsRespValidationError) 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 %sGetArtistAyrShareInfoByPlatformIDsResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetArtistAyrShareInfoByPlatformIDsRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetArtistAyrShareInfoByPlatformIDsRespValidationError{}

// Validate checks the field values on ListWorkPlatformInfoReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListWorkPlatformInfoReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListWorkPlatformInfoReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListWorkPlatformInfoReqMultiError, or nil if none found.
func (m *ListWorkPlatformInfoReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListWorkPlatformInfoReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PublishMediaStatus

	// no validation rules for Page

	// no validation rules for PageSize

	if len(errors) > 0 {
		return ListWorkPlatformInfoReqMultiError(errors)
	}

	return nil
}

// ListWorkPlatformInfoReqMultiError is an error wrapping multiple validation
// errors returned by ListWorkPlatformInfoReq.ValidateAll() if the designated
// constraints aren't met.
type ListWorkPlatformInfoReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListWorkPlatformInfoReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListWorkPlatformInfoReqMultiError) AllErrors() []error { return m }

// ListWorkPlatformInfoReqValidationError is the validation error returned by
// ListWorkPlatformInfoReq.Validate if the designated constraints aren't met.
type ListWorkPlatformInfoReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListWorkPlatformInfoReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListWorkPlatformInfoReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListWorkPlatformInfoReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListWorkPlatformInfoReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListWorkPlatformInfoReqValidationError) ErrorName() string {
	return "ListWorkPlatformInfoReqValidationError"
}

// Error satisfies the builtin error interface
func (e ListWorkPlatformInfoReqValidationError) 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 %sListWorkPlatformInfoReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListWorkPlatformInfoReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListWorkPlatformInfoReqValidationError{}

// Validate checks the field values on WorkPlatformInfo with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *WorkPlatformInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkPlatformInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkPlatformInfoMultiError, or nil if none found.
func (m *WorkPlatformInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkPlatformInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for WorkUuid

	// no validation rules for MediaUserID

	// no validation rules for PlatformID

	// no validation rules for PublishResp

	// no validation rules for PublishMediaID

	// no validation rules for PublishMediaStatus

	// no validation rules for Remark

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	// no validation rules for ArtistUuid

	// no validation rules for PlatformUserName

	// no validation rules for PlatformUserID

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	if len(errors) > 0 {
		return WorkPlatformInfoMultiError(errors)
	}

	return nil
}

// WorkPlatformInfoMultiError is an error wrapping multiple validation errors
// returned by WorkPlatformInfo.ValidateAll() if the designated constraints
// aren't met.
type WorkPlatformInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkPlatformInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkPlatformInfoMultiError) AllErrors() []error { return m }

// WorkPlatformInfoValidationError is the validation error returned by
// WorkPlatformInfo.Validate if the designated constraints aren't met.
type WorkPlatformInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e WorkPlatformInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e WorkPlatformInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e WorkPlatformInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e WorkPlatformInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e WorkPlatformInfoValidationError) ErrorName() string { return "WorkPlatformInfoValidationError" }

// Error satisfies the builtin error interface
func (e WorkPlatformInfoValidationError) 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 %sWorkPlatformInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkPlatformInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = WorkPlatformInfoValidationError{}

// Validate checks the field values on ListWorkPlatformInfoResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListWorkPlatformInfoResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListWorkPlatformInfoResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListWorkPlatformInfoRespMultiError, or nil if none found.
func (m *ListWorkPlatformInfoResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListWorkPlatformInfoResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListWorkPlatformInfoRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListWorkPlatformInfoRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListWorkPlatformInfoRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ListWorkPlatformInfoRespMultiError(errors)
	}

	return nil
}

// ListWorkPlatformInfoRespMultiError is an error wrapping multiple validation
// errors returned by ListWorkPlatformInfoResp.ValidateAll() if the designated
// constraints aren't met.
type ListWorkPlatformInfoRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListWorkPlatformInfoRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListWorkPlatformInfoRespMultiError) AllErrors() []error { return m }

// ListWorkPlatformInfoRespValidationError is the validation error returned by
// ListWorkPlatformInfoResp.Validate if the designated constraints aren't met.
type ListWorkPlatformInfoRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListWorkPlatformInfoRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListWorkPlatformInfoRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListWorkPlatformInfoRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListWorkPlatformInfoRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListWorkPlatformInfoRespValidationError) ErrorName() string {
	return "ListWorkPlatformInfoRespValidationError"
}

// Error satisfies the builtin error interface
func (e ListWorkPlatformInfoRespValidationError) 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 %sListWorkPlatformInfoResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListWorkPlatformInfoRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListWorkPlatformInfoRespValidationError{}

// Validate checks the field values on ListMediaMetricsDailyReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListMediaMetricsDailyReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListMediaMetricsDailyReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListMediaMetricsDailyReqMultiError, or nil if none found.
func (m *ListMediaMetricsDailyReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListMediaMetricsDailyReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for IsSuccess

	// no validation rules for FailType

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for Date

	if len(errors) > 0 {
		return ListMediaMetricsDailyReqMultiError(errors)
	}

	return nil
}

// ListMediaMetricsDailyReqMultiError is an error wrapping multiple validation
// errors returned by ListMediaMetricsDailyReq.ValidateAll() if the designated
// constraints aren't met.
type ListMediaMetricsDailyReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListMediaMetricsDailyReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListMediaMetricsDailyReqMultiError) AllErrors() []error { return m }

// ListMediaMetricsDailyReqValidationError is the validation error returned by
// ListMediaMetricsDailyReq.Validate if the designated constraints aren't met.
type ListMediaMetricsDailyReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListMediaMetricsDailyReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListMediaMetricsDailyReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListMediaMetricsDailyReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListMediaMetricsDailyReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListMediaMetricsDailyReqValidationError) ErrorName() string {
	return "ListMediaMetricsDailyReqValidationError"
}

// Error satisfies the builtin error interface
func (e ListMediaMetricsDailyReqValidationError) 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 %sListMediaMetricsDailyReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListMediaMetricsDailyReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListMediaMetricsDailyReqValidationError{}

// Validate checks the field values on MediaMetricsDailyInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *MediaMetricsDailyInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaMetricsDailyInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaMetricsDailyInfoMultiError, or nil if none found.
func (m *MediaMetricsDailyInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaMetricsDailyInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for ArtistUuid

	// no validation rules for MediaAccUserID

	// no validation rules for MediaName

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for PlatformID

	// no validation rules for Date

	// no validation rules for FansCount

	// no validation rules for ViewsCount

	// no validation rules for LikesCount

	// no validation rules for CommentsCount

	// no validation rules for SharesCount

	// no validation rules for VideoCount

	// no validation rules for ImageCount

	// no validation rules for ProfileKey

	// no validation rules for IsSuccess

	// no validation rules for FailReason

	// no validation rules for FailType

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return MediaMetricsDailyInfoMultiError(errors)
	}

	return nil
}

// MediaMetricsDailyInfoMultiError is an error wrapping multiple validation
// errors returned by MediaMetricsDailyInfo.ValidateAll() if the designated
// constraints aren't met.
type MediaMetricsDailyInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaMetricsDailyInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaMetricsDailyInfoMultiError) AllErrors() []error { return m }

// MediaMetricsDailyInfoValidationError is the validation error returned by
// MediaMetricsDailyInfo.Validate if the designated constraints aren't met.
type MediaMetricsDailyInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MediaMetricsDailyInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MediaMetricsDailyInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MediaMetricsDailyInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MediaMetricsDailyInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MediaMetricsDailyInfoValidationError) ErrorName() string {
	return "MediaMetricsDailyInfoValidationError"
}

// Error satisfies the builtin error interface
func (e MediaMetricsDailyInfoValidationError) 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 %sMediaMetricsDailyInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaMetricsDailyInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MediaMetricsDailyInfoValidationError{}

// Validate checks the field values on ListMediaMetricsDailyResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListMediaMetricsDailyResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListMediaMetricsDailyResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListMediaMetricsDailyRespMultiError, or nil if none found.
func (m *ListMediaMetricsDailyResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListMediaMetricsDailyResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListMediaMetricsDailyRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListMediaMetricsDailyRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListMediaMetricsDailyRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ListMediaMetricsDailyRespMultiError(errors)
	}

	return nil
}

// ListMediaMetricsDailyRespMultiError is an error wrapping multiple validation
// errors returned by ListMediaMetricsDailyResp.ValidateAll() if the
// designated constraints aren't met.
type ListMediaMetricsDailyRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListMediaMetricsDailyRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListMediaMetricsDailyRespMultiError) AllErrors() []error { return m }

// ListMediaMetricsDailyRespValidationError is the validation error returned by
// ListMediaMetricsDailyResp.Validate if the designated constraints aren't met.
type ListMediaMetricsDailyRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListMediaMetricsDailyRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListMediaMetricsDailyRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListMediaMetricsDailyRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListMediaMetricsDailyRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListMediaMetricsDailyRespValidationError) ErrorName() string {
	return "ListMediaMetricsDailyRespValidationError"
}

// Error satisfies the builtin error interface
func (e ListMediaMetricsDailyRespValidationError) 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 %sListMediaMetricsDailyResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListMediaMetricsDailyRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListMediaMetricsDailyRespValidationError{}

// Validate checks the field values on ListWorkMetricsDailyReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListWorkMetricsDailyReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListWorkMetricsDailyReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListWorkMetricsDailyReqMultiError, or nil if none found.
func (m *ListWorkMetricsDailyReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListWorkMetricsDailyReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for IsSuccess

	// no validation rules for FailType

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for Date

	if len(errors) > 0 {
		return ListWorkMetricsDailyReqMultiError(errors)
	}

	return nil
}

// ListWorkMetricsDailyReqMultiError is an error wrapping multiple validation
// errors returned by ListWorkMetricsDailyReq.ValidateAll() if the designated
// constraints aren't met.
type ListWorkMetricsDailyReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListWorkMetricsDailyReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListWorkMetricsDailyReqMultiError) AllErrors() []error { return m }

// ListWorkMetricsDailyReqValidationError is the validation error returned by
// ListWorkMetricsDailyReq.Validate if the designated constraints aren't met.
type ListWorkMetricsDailyReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListWorkMetricsDailyReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListWorkMetricsDailyReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListWorkMetricsDailyReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListWorkMetricsDailyReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListWorkMetricsDailyReqValidationError) ErrorName() string {
	return "ListWorkMetricsDailyReqValidationError"
}

// Error satisfies the builtin error interface
func (e ListWorkMetricsDailyReqValidationError) 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 %sListWorkMetricsDailyReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListWorkMetricsDailyReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListWorkMetricsDailyReqValidationError{}

// Validate checks the field values on WorkMetricsDailyInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkMetricsDailyInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkMetricsDailyInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkMetricsDailyInfoMultiError, or nil if none found.
func (m *WorkMetricsDailyInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkMetricsDailyInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for WorkUuid

	// no validation rules for ArtistUuid

	// no validation rules for MediaAccUserID

	// no validation rules for MediaName

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for PlatformID

	// no validation rules for Date

	// no validation rules for ViewsCount

	// no validation rules for LikesCount

	// no validation rules for CommentsCount

	// no validation rules for SharesCount

	// no validation rules for PublishMediaID

	// no validation rules for ProfileKey

	// no validation rules for IsSuccess

	// no validation rules for FailReason

	// no validation rules for FailType

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return WorkMetricsDailyInfoMultiError(errors)
	}

	return nil
}

// WorkMetricsDailyInfoMultiError is an error wrapping multiple validation
// errors returned by WorkMetricsDailyInfo.ValidateAll() if the designated
// constraints aren't met.
type WorkMetricsDailyInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkMetricsDailyInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkMetricsDailyInfoMultiError) AllErrors() []error { return m }

// WorkMetricsDailyInfoValidationError is the validation error returned by
// WorkMetricsDailyInfo.Validate if the designated constraints aren't met.
type WorkMetricsDailyInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e WorkMetricsDailyInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e WorkMetricsDailyInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e WorkMetricsDailyInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e WorkMetricsDailyInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e WorkMetricsDailyInfoValidationError) ErrorName() string {
	return "WorkMetricsDailyInfoValidationError"
}

// Error satisfies the builtin error interface
func (e WorkMetricsDailyInfoValidationError) 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 %sWorkMetricsDailyInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkMetricsDailyInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = WorkMetricsDailyInfoValidationError{}

// Validate checks the field values on ListWorkMetricsDailyResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListWorkMetricsDailyResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListWorkMetricsDailyResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListWorkMetricsDailyRespMultiError, or nil if none found.
func (m *ListWorkMetricsDailyResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListWorkMetricsDailyResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListWorkMetricsDailyRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListWorkMetricsDailyRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListWorkMetricsDailyRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ListWorkMetricsDailyRespMultiError(errors)
	}

	return nil
}

// ListWorkMetricsDailyRespMultiError is an error wrapping multiple validation
// errors returned by ListWorkMetricsDailyResp.ValidateAll() if the designated
// constraints aren't met.
type ListWorkMetricsDailyRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListWorkMetricsDailyRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListWorkMetricsDailyRespMultiError) AllErrors() []error { return m }

// ListWorkMetricsDailyRespValidationError is the validation error returned by
// ListWorkMetricsDailyResp.Validate if the designated constraints aren't met.
type ListWorkMetricsDailyRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListWorkMetricsDailyRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListWorkMetricsDailyRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListWorkMetricsDailyRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListWorkMetricsDailyRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListWorkMetricsDailyRespValidationError) ErrorName() string {
	return "ListWorkMetricsDailyRespValidationError"
}

// Error satisfies the builtin error interface
func (e ListWorkMetricsDailyRespValidationError) 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 %sListWorkMetricsDailyResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListWorkMetricsDailyRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListWorkMetricsDailyRespValidationError{}

// Validate checks the field values on UpsertTaskListReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UpsertTaskListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpsertTaskListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpsertTaskListReqMultiError, or nil if none found.
func (m *UpsertTaskListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpsertTaskListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Action

	// no validation rules for Url

	// no validation rules for Status

	// no validation rules for OperatorID

	// no validation rules for OperatorName

	// no validation rules for ExtraData

	if len(errors) > 0 {
		return UpsertTaskListReqMultiError(errors)
	}

	return nil
}

// UpsertTaskListReqMultiError is an error wrapping multiple validation errors
// returned by UpsertTaskListReq.ValidateAll() if the designated constraints
// aren't met.
type UpsertTaskListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpsertTaskListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpsertTaskListReqMultiError) AllErrors() []error { return m }

// UpsertTaskListReqValidationError is the validation error returned by
// UpsertTaskListReq.Validate if the designated constraints aren't met.
type UpsertTaskListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpsertTaskListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpsertTaskListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpsertTaskListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpsertTaskListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpsertTaskListReqValidationError) ErrorName() string {
	return "UpsertTaskListReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpsertTaskListReqValidationError) 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 %sUpsertTaskListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpsertTaskListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpsertTaskListReqValidationError{}

// Validate checks the field values on UpsertTaskListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpsertTaskListResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpsertTaskListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpsertTaskListRespMultiError, or nil if none found.
func (m *UpsertTaskListResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpsertTaskListResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Msg

	if len(errors) > 0 {
		return UpsertTaskListRespMultiError(errors)
	}

	return nil
}

// UpsertTaskListRespMultiError is an error wrapping multiple validation errors
// returned by UpsertTaskListResp.ValidateAll() if the designated constraints
// aren't met.
type UpsertTaskListRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpsertTaskListRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpsertTaskListRespMultiError) AllErrors() []error { return m }

// UpsertTaskListRespValidationError is the validation error returned by
// UpsertTaskListResp.Validate if the designated constraints aren't met.
type UpsertTaskListRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpsertTaskListRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpsertTaskListRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpsertTaskListRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpsertTaskListRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpsertTaskListRespValidationError) ErrorName() string {
	return "UpsertTaskListRespValidationError"
}

// Error satisfies the builtin error interface
func (e UpsertTaskListRespValidationError) 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 %sUpsertTaskListResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpsertTaskListRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpsertTaskListRespValidationError{}

// Validate checks the field values on GetTaskListReq with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *GetTaskListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetTaskListReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in GetTaskListReqMultiError,
// or nil if none found.
func (m *GetTaskListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetTaskListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return GetTaskListReqMultiError(errors)
	}

	return nil
}

// GetTaskListReqMultiError is an error wrapping multiple validation errors
// returned by GetTaskListReq.ValidateAll() if the designated constraints
// aren't met.
type GetTaskListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetTaskListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetTaskListReqMultiError) AllErrors() []error { return m }

// GetTaskListReqValidationError is the validation error returned by
// GetTaskListReq.Validate if the designated constraints aren't met.
type GetTaskListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetTaskListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetTaskListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetTaskListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetTaskListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetTaskListReqValidationError) ErrorName() string { return "GetTaskListReqValidationError" }

// Error satisfies the builtin error interface
func (e GetTaskListReqValidationError) 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 %sGetTaskListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetTaskListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetTaskListReqValidationError{}

// Validate checks the field values on TaskListInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *TaskListInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on TaskListInfo with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in TaskListInfoMultiError, or
// nil if none found.
func (m *TaskListInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *TaskListInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Action

	// no validation rules for Url

	// no validation rules for Status

	// no validation rules for OperatorID

	// no validation rules for OperatorName

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	// no validation rules for ExtraData

	if len(errors) > 0 {
		return TaskListInfoMultiError(errors)
	}

	return nil
}

// TaskListInfoMultiError is an error wrapping multiple validation errors
// returned by TaskListInfo.ValidateAll() if the designated constraints aren't met.
type TaskListInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m TaskListInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m TaskListInfoMultiError) AllErrors() []error { return m }

// TaskListInfoValidationError is the validation error returned by
// TaskListInfo.Validate if the designated constraints aren't met.
type TaskListInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e TaskListInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e TaskListInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e TaskListInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e TaskListInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e TaskListInfoValidationError) ErrorName() string { return "TaskListInfoValidationError" }

// Error satisfies the builtin error interface
func (e TaskListInfoValidationError) 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 %sTaskListInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = TaskListInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = TaskListInfoValidationError{}

// Validate checks the field values on GetTaskListResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *GetTaskListResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetTaskListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetTaskListRespMultiError, or nil if none found.
func (m *GetTaskListResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetTaskListResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if all {
		switch v := interface{}(m.GetData()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetTaskListRespValidationError{
					field:  "Data",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetTaskListRespValidationError{
					field:  "Data",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetData()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetTaskListRespValidationError{
				field:  "Data",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for Msg

	if len(errors) > 0 {
		return GetTaskListRespMultiError(errors)
	}

	return nil
}

// GetTaskListRespMultiError is an error wrapping multiple validation errors
// returned by GetTaskListResp.ValidateAll() if the designated constraints
// aren't met.
type GetTaskListRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetTaskListRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetTaskListRespMultiError) AllErrors() []error { return m }

// GetTaskListRespValidationError is the validation error returned by
// GetTaskListResp.Validate if the designated constraints aren't met.
type GetTaskListRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetTaskListRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetTaskListRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetTaskListRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetTaskListRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetTaskListRespValidationError) ErrorName() string { return "GetTaskListRespValidationError" }

// Error satisfies the builtin error interface
func (e GetTaskListRespValidationError) 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 %sGetTaskListResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetTaskListRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetTaskListRespValidationError{}

// Validate checks the field values on ListTaskListReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *ListTaskListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListTaskListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListTaskListReqMultiError, or nil if none found.
func (m *ListTaskListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListTaskListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Action

	// no validation rules for Status

	// no validation rules for OperatorID

	// no validation rules for Page

	// no validation rules for PageSize

	if len(errors) > 0 {
		return ListTaskListReqMultiError(errors)
	}

	return nil
}

// ListTaskListReqMultiError is an error wrapping multiple validation errors
// returned by ListTaskListReq.ValidateAll() if the designated constraints
// aren't met.
type ListTaskListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListTaskListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListTaskListReqMultiError) AllErrors() []error { return m }

// ListTaskListReqValidationError is the validation error returned by
// ListTaskListReq.Validate if the designated constraints aren't met.
type ListTaskListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListTaskListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListTaskListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListTaskListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListTaskListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListTaskListReqValidationError) ErrorName() string { return "ListTaskListReqValidationError" }

// Error satisfies the builtin error interface
func (e ListTaskListReqValidationError) 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 %sListTaskListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListTaskListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListTaskListReqValidationError{}

// Validate checks the field values on ListTaskListResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *ListTaskListResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListTaskListResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListTaskListRespMultiError, or nil if none found.
func (m *ListTaskListResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListTaskListResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListTaskListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListTaskListRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListTaskListRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	// no validation rules for Msg

	if len(errors) > 0 {
		return ListTaskListRespMultiError(errors)
	}

	return nil
}

// ListTaskListRespMultiError is an error wrapping multiple validation errors
// returned by ListTaskListResp.ValidateAll() if the designated constraints
// aren't met.
type ListTaskListRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListTaskListRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListTaskListRespMultiError) AllErrors() []error { return m }

// ListTaskListRespValidationError is the validation error returned by
// ListTaskListResp.Validate if the designated constraints aren't met.
type ListTaskListRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListTaskListRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListTaskListRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListTaskListRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListTaskListRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListTaskListRespValidationError) ErrorName() string { return "ListTaskListRespValidationError" }

// Error satisfies the builtin error interface
func (e ListTaskListRespValidationError) 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 %sListTaskListResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListTaskListRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListTaskListRespValidationError{}

// Validate checks the field values on DeleteTaskListReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *DeleteTaskListReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DeleteTaskListReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// DeleteTaskListReqMultiError, or nil if none found.
func (m *DeleteTaskListReq) ValidateAll() error {
	return m.validate(true)
}

func (m *DeleteTaskListReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return DeleteTaskListReqMultiError(errors)
	}

	return nil
}

// DeleteTaskListReqMultiError is an error wrapping multiple validation errors
// returned by DeleteTaskListReq.ValidateAll() if the designated constraints
// aren't met.
type DeleteTaskListReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m DeleteTaskListReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m DeleteTaskListReqMultiError) AllErrors() []error { return m }

// DeleteTaskListReqValidationError is the validation error returned by
// DeleteTaskListReq.Validate if the designated constraints aren't met.
type DeleteTaskListReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e DeleteTaskListReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e DeleteTaskListReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e DeleteTaskListReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e DeleteTaskListReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e DeleteTaskListReqValidationError) ErrorName() string {
	return "DeleteTaskListReqValidationError"
}

// Error satisfies the builtin error interface
func (e DeleteTaskListReqValidationError) 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 %sDeleteTaskListReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DeleteTaskListReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = DeleteTaskListReqValidationError{}

// Validate checks the field values on CalculateMediaMetricsByWorksReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CalculateMediaMetricsByWorksReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CalculateMediaMetricsByWorksReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// CalculateMediaMetricsByWorksReqMultiError, or nil if none found.
func (m *CalculateMediaMetricsByWorksReq) ValidateAll() error {
	return m.validate(true)
}

func (m *CalculateMediaMetricsByWorksReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Date

	if len(errors) > 0 {
		return CalculateMediaMetricsByWorksReqMultiError(errors)
	}

	return nil
}

// CalculateMediaMetricsByWorksReqMultiError is an error wrapping multiple
// validation errors returned by CalculateMediaMetricsByWorksReq.ValidateAll()
// if the designated constraints aren't met.
type CalculateMediaMetricsByWorksReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CalculateMediaMetricsByWorksReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CalculateMediaMetricsByWorksReqMultiError) AllErrors() []error { return m }

// CalculateMediaMetricsByWorksReqValidationError is the validation error
// returned by CalculateMediaMetricsByWorksReq.Validate if the designated
// constraints aren't met.
type CalculateMediaMetricsByWorksReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CalculateMediaMetricsByWorksReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CalculateMediaMetricsByWorksReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CalculateMediaMetricsByWorksReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CalculateMediaMetricsByWorksReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CalculateMediaMetricsByWorksReqValidationError) ErrorName() string {
	return "CalculateMediaMetricsByWorksReqValidationError"
}

// Error satisfies the builtin error interface
func (e CalculateMediaMetricsByWorksReqValidationError) 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 %sCalculateMediaMetricsByWorksReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CalculateMediaMetricsByWorksReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CalculateMediaMetricsByWorksReqValidationError{}

// Validate checks the field values on CalculateMediaMetricsByWorksResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the first error encountered is returned, or nil if there are
// no violations.
func (m *CalculateMediaMetricsByWorksResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CalculateMediaMetricsByWorksResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// CalculateMediaMetricsByWorksRespMultiError, or nil if none found.
func (m *CalculateMediaMetricsByWorksResp) ValidateAll() error {
	return m.validate(true)
}

func (m *CalculateMediaMetricsByWorksResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Success

	if len(errors) > 0 {
		return CalculateMediaMetricsByWorksRespMultiError(errors)
	}

	return nil
}

// CalculateMediaMetricsByWorksRespMultiError is an error wrapping multiple
// validation errors returned by
// CalculateMediaMetricsByWorksResp.ValidateAll() if the designated
// constraints aren't met.
type CalculateMediaMetricsByWorksRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CalculateMediaMetricsByWorksRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CalculateMediaMetricsByWorksRespMultiError) AllErrors() []error { return m }

// CalculateMediaMetricsByWorksRespValidationError is the validation error
// returned by CalculateMediaMetricsByWorksResp.Validate if the designated
// constraints aren't met.
type CalculateMediaMetricsByWorksRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CalculateMediaMetricsByWorksRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CalculateMediaMetricsByWorksRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CalculateMediaMetricsByWorksRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CalculateMediaMetricsByWorksRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CalculateMediaMetricsByWorksRespValidationError) ErrorName() string {
	return "CalculateMediaMetricsByWorksRespValidationError"
}

// Error satisfies the builtin error interface
func (e CalculateMediaMetricsByWorksRespValidationError) 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 %sCalculateMediaMetricsByWorksResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CalculateMediaMetricsByWorksRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CalculateMediaMetricsByWorksRespValidationError{}

// Validate checks the field values on UpdateCastTagReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UpdateCastTagReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateCastTagReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateCastTagReqMultiError, or nil if none found.
func (m *UpdateCastTagReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateCastTagReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for HashTag

	// no validation rules for Source

	// no validation rules for Status

	// no validation rules for Remark

	if len(errors) > 0 {
		return UpdateCastTagReqMultiError(errors)
	}

	return nil
}

// UpdateCastTagReqMultiError is an error wrapping multiple validation errors
// returned by UpdateCastTagReq.ValidateAll() if the designated constraints
// aren't met.
type UpdateCastTagReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateCastTagReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateCastTagReqMultiError) AllErrors() []error { return m }

// UpdateCastTagReqValidationError is the validation error returned by
// UpdateCastTagReq.Validate if the designated constraints aren't met.
type UpdateCastTagReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateCastTagReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateCastTagReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateCastTagReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateCastTagReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateCastTagReqValidationError) ErrorName() string { return "UpdateCastTagReqValidationError" }

// Error satisfies the builtin error interface
func (e UpdateCastTagReqValidationError) 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 %sUpdateCastTagReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateCastTagReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateCastTagReqValidationError{}

// Validate checks the field values on UpdateCastTagResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *UpdateCastTagResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateCastTagResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateCastTagRespMultiError, or nil if none found.
func (m *UpdateCastTagResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateCastTagResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return UpdateCastTagRespMultiError(errors)
	}

	return nil
}

// UpdateCastTagRespMultiError is an error wrapping multiple validation errors
// returned by UpdateCastTagResp.ValidateAll() if the designated constraints
// aren't met.
type UpdateCastTagRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateCastTagRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateCastTagRespMultiError) AllErrors() []error { return m }

// UpdateCastTagRespValidationError is the validation error returned by
// UpdateCastTagResp.Validate if the designated constraints aren't met.
type UpdateCastTagRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateCastTagRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateCastTagRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateCastTagRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateCastTagRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateCastTagRespValidationError) ErrorName() string {
	return "UpdateCastTagRespValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateCastTagRespValidationError) 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 %sUpdateCastTagResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateCastTagRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateCastTagRespValidationError{}

// Validate checks the field values on ListCastTagsReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *ListCastTagsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListCastTagsReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListCastTagsReqMultiError, or nil if none found.
func (m *ListCastTagsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListCastTagsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for HashTag

	// no validation rules for Source

	// no validation rules for Status

	// no validation rules for StatusUpdateTimeStart

	// no validation rules for StatusUpdateTimeEnd

	// no validation rules for CreatedAtStart

	// no validation rules for CreatedAtEnd

	// no validation rules for IsWatchCountCalled

	// no validation rules for OrderBy

	// no validation rules for Sort

	// no validation rules for Page

	// no validation rules for PageSize

	if len(errors) > 0 {
		return ListCastTagsReqMultiError(errors)
	}

	return nil
}

// ListCastTagsReqMultiError is an error wrapping multiple validation errors
// returned by ListCastTagsReq.ValidateAll() if the designated constraints
// aren't met.
type ListCastTagsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListCastTagsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListCastTagsReqMultiError) AllErrors() []error { return m }

// ListCastTagsReqValidationError is the validation error returned by
// ListCastTagsReq.Validate if the designated constraints aren't met.
type ListCastTagsReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListCastTagsReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListCastTagsReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListCastTagsReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListCastTagsReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListCastTagsReqValidationError) ErrorName() string { return "ListCastTagsReqValidationError" }

// Error satisfies the builtin error interface
func (e ListCastTagsReqValidationError) 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 %sListCastTagsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListCastTagsReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListCastTagsReqValidationError{}

// Validate checks the field values on CastTagInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *CastTagInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CastTagInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in CastTagInfoMultiError, or
// nil if none found.
func (m *CastTagInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *CastTagInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for HashTag

	// no validation rules for CreatorUuid

	// no validation rules for CreatorName

	// no validation rules for Source

	// no validation rules for QuoteCount

	// no validation rules for WatchCount

	// no validation rules for Status

	// no validation rules for Remark

	// no validation rules for StatusUpdateTime

	// no validation rules for CreatedDate

	// no validation rules for Success

	// no validation rules for IsWatchCountCalled

	if len(errors) > 0 {
		return CastTagInfoMultiError(errors)
	}

	return nil
}

// CastTagInfoMultiError is an error wrapping multiple validation errors
// returned by CastTagInfo.ValidateAll() if the designated constraints aren't met.
type CastTagInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CastTagInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CastTagInfoMultiError) AllErrors() []error { return m }

// CastTagInfoValidationError is the validation error returned by
// CastTagInfo.Validate if the designated constraints aren't met.
type CastTagInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CastTagInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CastTagInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CastTagInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CastTagInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CastTagInfoValidationError) ErrorName() string { return "CastTagInfoValidationError" }

// Error satisfies the builtin error interface
func (e CastTagInfoValidationError) 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 %sCastTagInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CastTagInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CastTagInfoValidationError{}

// Validate checks the field values on ListCastTagsResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *ListCastTagsResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListCastTagsResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListCastTagsRespMultiError, or nil if none found.
func (m *ListCastTagsResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListCastTagsResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListCastTagsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListCastTagsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListCastTagsRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ListCastTagsRespMultiError(errors)
	}

	return nil
}

// ListCastTagsRespMultiError is an error wrapping multiple validation errors
// returned by ListCastTagsResp.ValidateAll() if the designated constraints
// aren't met.
type ListCastTagsRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListCastTagsRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListCastTagsRespMultiError) AllErrors() []error { return m }

// ListCastTagsRespValidationError is the validation error returned by
// ListCastTagsResp.Validate if the designated constraints aren't met.
type ListCastTagsRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListCastTagsRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListCastTagsRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListCastTagsRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListCastTagsRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListCastTagsRespValidationError) ErrorName() string { return "ListCastTagsRespValidationError" }

// Error satisfies the builtin error interface
func (e ListCastTagsRespValidationError) 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 %sListCastTagsResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListCastTagsRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListCastTagsRespValidationError{}

// Validate checks the field values on UpdateCastTagBatchReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateCastTagBatchReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateCastTagBatchReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateCastTagBatchReqMultiError, or nil if none found.
func (m *UpdateCastTagBatchReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateCastTagBatchReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpdateCastTagBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpdateCastTagBatchReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpdateCastTagBatchReqValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return UpdateCastTagBatchReqMultiError(errors)
	}

	return nil
}

// UpdateCastTagBatchReqMultiError is an error wrapping multiple validation
// errors returned by UpdateCastTagBatchReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateCastTagBatchReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateCastTagBatchReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateCastTagBatchReqMultiError) AllErrors() []error { return m }

// UpdateCastTagBatchReqValidationError is the validation error returned by
// UpdateCastTagBatchReq.Validate if the designated constraints aren't met.
type UpdateCastTagBatchReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateCastTagBatchReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateCastTagBatchReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateCastTagBatchReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateCastTagBatchReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateCastTagBatchReqValidationError) ErrorName() string {
	return "UpdateCastTagBatchReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateCastTagBatchReqValidationError) 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 %sUpdateCastTagBatchReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateCastTagBatchReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateCastTagBatchReqValidationError{}

// Validate checks the field values on UpdateCastTagBatchResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateCastTagBatchResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateCastTagBatchResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateCastTagBatchRespMultiError, or nil if none found.
func (m *UpdateCastTagBatchResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateCastTagBatchResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, UpdateCastTagBatchRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, UpdateCastTagBatchRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return UpdateCastTagBatchRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for SuccessCount

	// no validation rules for FailCount

	if len(errors) > 0 {
		return UpdateCastTagBatchRespMultiError(errors)
	}

	return nil
}

// UpdateCastTagBatchRespMultiError is an error wrapping multiple validation
// errors returned by UpdateCastTagBatchResp.ValidateAll() if the designated
// constraints aren't met.
type UpdateCastTagBatchRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateCastTagBatchRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateCastTagBatchRespMultiError) AllErrors() []error { return m }

// UpdateCastTagBatchRespValidationError is the validation error returned by
// UpdateCastTagBatchResp.Validate if the designated constraints aren't met.
type UpdateCastTagBatchRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateCastTagBatchRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateCastTagBatchRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateCastTagBatchRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateCastTagBatchRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateCastTagBatchRespValidationError) ErrorName() string {
	return "UpdateCastTagBatchRespValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateCastTagBatchRespValidationError) 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 %sUpdateCastTagBatchResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateCastTagBatchRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateCastTagBatchRespValidationError{}

// Validate checks the field values on BatchUpdateCastTagsReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *BatchUpdateCastTagsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on BatchUpdateCastTagsReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// BatchUpdateCastTagsReqMultiError, or nil if none found.
func (m *BatchUpdateCastTagsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *BatchUpdateCastTagsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, BatchUpdateCastTagsReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, BatchUpdateCastTagsReqValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return BatchUpdateCastTagsReqValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return BatchUpdateCastTagsReqMultiError(errors)
	}

	return nil
}

// BatchUpdateCastTagsReqMultiError is an error wrapping multiple validation
// errors returned by BatchUpdateCastTagsReq.ValidateAll() if the designated
// constraints aren't met.
type BatchUpdateCastTagsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m BatchUpdateCastTagsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m BatchUpdateCastTagsReqMultiError) AllErrors() []error { return m }

// BatchUpdateCastTagsReqValidationError is the validation error returned by
// BatchUpdateCastTagsReq.Validate if the designated constraints aren't met.
type BatchUpdateCastTagsReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e BatchUpdateCastTagsReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e BatchUpdateCastTagsReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e BatchUpdateCastTagsReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e BatchUpdateCastTagsReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e BatchUpdateCastTagsReqValidationError) ErrorName() string {
	return "BatchUpdateCastTagsReqValidationError"
}

// Error satisfies the builtin error interface
func (e BatchUpdateCastTagsReqValidationError) 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 %sBatchUpdateCastTagsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = BatchUpdateCastTagsReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = BatchUpdateCastTagsReqValidationError{}

// Validate checks the field values on UpdateCastTagStatusReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateCastTagStatusReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateCastTagStatusReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateCastTagStatusReqMultiError, or nil if none found.
func (m *UpdateCastTagStatusReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateCastTagStatusReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for HashTag

	// no validation rules for Status

	// no validation rules for Remark

	if len(errors) > 0 {
		return UpdateCastTagStatusReqMultiError(errors)
	}

	return nil
}

// UpdateCastTagStatusReqMultiError is an error wrapping multiple validation
// errors returned by UpdateCastTagStatusReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateCastTagStatusReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateCastTagStatusReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateCastTagStatusReqMultiError) AllErrors() []error { return m }

// UpdateCastTagStatusReqValidationError is the validation error returned by
// UpdateCastTagStatusReq.Validate if the designated constraints aren't met.
type UpdateCastTagStatusReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateCastTagStatusReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateCastTagStatusReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateCastTagStatusReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateCastTagStatusReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateCastTagStatusReqValidationError) ErrorName() string {
	return "UpdateCastTagStatusReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateCastTagStatusReqValidationError) 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 %sUpdateCastTagStatusReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateCastTagStatusReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateCastTagStatusReqValidationError{}

// Validate checks the field values on RecalculateCastTagQuoteCountResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the first error encountered is returned, or nil if there are
// no violations.
func (m *RecalculateCastTagQuoteCountResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RecalculateCastTagQuoteCountResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// RecalculateCastTagQuoteCountRespMultiError, or nil if none found.
func (m *RecalculateCastTagQuoteCountResp) ValidateAll() error {
	return m.validate(true)
}

func (m *RecalculateCastTagQuoteCountResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Success

	// no validation rules for Msg

	if len(errors) > 0 {
		return RecalculateCastTagQuoteCountRespMultiError(errors)
	}

	return nil
}

// RecalculateCastTagQuoteCountRespMultiError is an error wrapping multiple
// validation errors returned by
// RecalculateCastTagQuoteCountResp.ValidateAll() if the designated
// constraints aren't met.
type RecalculateCastTagQuoteCountRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m RecalculateCastTagQuoteCountRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m RecalculateCastTagQuoteCountRespMultiError) AllErrors() []error { return m }

// RecalculateCastTagQuoteCountRespValidationError is the validation error
// returned by RecalculateCastTagQuoteCountResp.Validate if the designated
// constraints aren't met.
type RecalculateCastTagQuoteCountRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e RecalculateCastTagQuoteCountRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e RecalculateCastTagQuoteCountRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e RecalculateCastTagQuoteCountRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e RecalculateCastTagQuoteCountRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e RecalculateCastTagQuoteCountRespValidationError) ErrorName() string {
	return "RecalculateCastTagQuoteCountRespValidationError"
}

// Error satisfies the builtin error interface
func (e RecalculateCastTagQuoteCountRespValidationError) 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 %sRecalculateCastTagQuoteCountResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RecalculateCastTagQuoteCountRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = RecalculateCastTagQuoteCountRespValidationError{}

// Validate checks the field values on CreateCompetitiveReportReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CreateCompetitiveReportReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CreateCompetitiveReportReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CreateCompetitiveReportReqMultiError, or nil if none found.
func (m *CreateCompetitiveReportReq) ValidateAll() error {
	return m.validate(true)
}

func (m *CreateCompetitiveReportReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SubNum

	// no validation rules for ArtistName

	// no validation rules for ArtistID

	// no validation rules for ArtistPhone

	// no validation rules for ReportContent

	// no validation rules for ImageUrl

	// no validation rules for Title

	// no validation rules for PdfUrl

	// no validation rules for Source

	// no validation rules for Remark

	// no validation rules for Success

	// no validation rules for BundleOrderUuid

	if len(errors) > 0 {
		return CreateCompetitiveReportReqMultiError(errors)
	}

	return nil
}

// CreateCompetitiveReportReqMultiError is an error wrapping multiple
// validation errors returned by CreateCompetitiveReportReq.ValidateAll() if
// the designated constraints aren't met.
type CreateCompetitiveReportReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CreateCompetitiveReportReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CreateCompetitiveReportReqMultiError) AllErrors() []error { return m }

// CreateCompetitiveReportReqValidationError is the validation error returned
// by CreateCompetitiveReportReq.Validate if the designated constraints aren't met.
type CreateCompetitiveReportReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CreateCompetitiveReportReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CreateCompetitiveReportReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CreateCompetitiveReportReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CreateCompetitiveReportReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CreateCompetitiveReportReqValidationError) ErrorName() string {
	return "CreateCompetitiveReportReqValidationError"
}

// Error satisfies the builtin error interface
func (e CreateCompetitiveReportReqValidationError) 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 %sCreateCompetitiveReportReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CreateCompetitiveReportReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CreateCompetitiveReportReqValidationError{}

// Validate checks the field values on CreateCompetitiveReportResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CreateCompetitiveReportResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CreateCompetitiveReportResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CreateCompetitiveReportRespMultiError, or nil if none found.
func (m *CreateCompetitiveReportResp) ValidateAll() error {
	return m.validate(true)
}

func (m *CreateCompetitiveReportResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for PdfUrl

	if len(errors) > 0 {
		return CreateCompetitiveReportRespMultiError(errors)
	}

	return nil
}

// CreateCompetitiveReportRespMultiError is an error wrapping multiple
// validation errors returned by CreateCompetitiveReportResp.ValidateAll() if
// the designated constraints aren't met.
type CreateCompetitiveReportRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CreateCompetitiveReportRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CreateCompetitiveReportRespMultiError) AllErrors() []error { return m }

// CreateCompetitiveReportRespValidationError is the validation error returned
// by CreateCompetitiveReportResp.Validate if the designated constraints
// aren't met.
type CreateCompetitiveReportRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CreateCompetitiveReportRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CreateCompetitiveReportRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CreateCompetitiveReportRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CreateCompetitiveReportRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CreateCompetitiveReportRespValidationError) ErrorName() string {
	return "CreateCompetitiveReportRespValidationError"
}

// Error satisfies the builtin error interface
func (e CreateCompetitiveReportRespValidationError) 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 %sCreateCompetitiveReportResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CreateCompetitiveReportRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CreateCompetitiveReportRespValidationError{}

// Validate checks the field values on UpdateCompetitiveReportReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateCompetitiveReportReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateCompetitiveReportReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateCompetitiveReportReqMultiError, or nil if none found.
func (m *UpdateCompetitiveReportReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateCompetitiveReportReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for ReportContent

	// no validation rules for Title

	// no validation rules for ImageUrl

	// no validation rules for PdfUrl

	if len(errors) > 0 {
		return UpdateCompetitiveReportReqMultiError(errors)
	}

	return nil
}

// UpdateCompetitiveReportReqMultiError is an error wrapping multiple
// validation errors returned by UpdateCompetitiveReportReq.ValidateAll() if
// the designated constraints aren't met.
type UpdateCompetitiveReportReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateCompetitiveReportReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateCompetitiveReportReqMultiError) AllErrors() []error { return m }

// UpdateCompetitiveReportReqValidationError is the validation error returned
// by UpdateCompetitiveReportReq.Validate if the designated constraints aren't met.
type UpdateCompetitiveReportReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateCompetitiveReportReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateCompetitiveReportReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateCompetitiveReportReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateCompetitiveReportReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateCompetitiveReportReqValidationError) ErrorName() string {
	return "UpdateCompetitiveReportReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateCompetitiveReportReqValidationError) 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 %sUpdateCompetitiveReportReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateCompetitiveReportReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateCompetitiveReportReqValidationError{}

// Validate checks the field values on UpdateCompetitiveReportStatusReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the first error encountered is returned, or nil if there are
// no violations.
func (m *UpdateCompetitiveReportStatusReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateCompetitiveReportStatusReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// UpdateCompetitiveReportStatusReqMultiError, or nil if none found.
func (m *UpdateCompetitiveReportStatusReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateCompetitiveReportStatusReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkAction

	// no validation rules for Uuid

	// no validation rules for ApprovalID

	// no validation rules for ApprovalReply

	// no validation rules for ConfirmRemark

	// no validation rules for ConfirmStatus

	// no validation rules for CostType

	// no validation rules for ConfirmType

	// no validation rules for ApprovalTime

	if len(errors) > 0 {
		return UpdateCompetitiveReportStatusReqMultiError(errors)
	}

	return nil
}

// UpdateCompetitiveReportStatusReqMultiError is an error wrapping multiple
// validation errors returned by
// UpdateCompetitiveReportStatusReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateCompetitiveReportStatusReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateCompetitiveReportStatusReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateCompetitiveReportStatusReqMultiError) AllErrors() []error { return m }

// UpdateCompetitiveReportStatusReqValidationError is the validation error
// returned by UpdateCompetitiveReportStatusReq.Validate if the designated
// constraints aren't met.
type UpdateCompetitiveReportStatusReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateCompetitiveReportStatusReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateCompetitiveReportStatusReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateCompetitiveReportStatusReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateCompetitiveReportStatusReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateCompetitiveReportStatusReqValidationError) ErrorName() string {
	return "UpdateCompetitiveReportStatusReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateCompetitiveReportStatusReqValidationError) 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 %sUpdateCompetitiveReportStatusReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateCompetitiveReportStatusReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateCompetitiveReportStatusReqValidationError{}

// Validate checks the field values on UpdateCompetitiveReportApprovalIDReq
// with the rules defined in the proto definition for this message. If any
// rules are violated, the first error encountered is returned, or nil if
// there are no violations.
func (m *UpdateCompetitiveReportApprovalIDReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateCompetitiveReportApprovalIDReq
// with the rules defined in the proto definition for this message. If any
// rules are violated, the result is a list of violation errors wrapped in
// UpdateCompetitiveReportApprovalIDReqMultiError, or nil if none found.
func (m *UpdateCompetitiveReportApprovalIDReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateCompetitiveReportApprovalIDReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for ApprovalID

	if len(errors) > 0 {
		return UpdateCompetitiveReportApprovalIDReqMultiError(errors)
	}

	return nil
}

// UpdateCompetitiveReportApprovalIDReqMultiError is an error wrapping multiple
// validation errors returned by
// UpdateCompetitiveReportApprovalIDReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateCompetitiveReportApprovalIDReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateCompetitiveReportApprovalIDReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateCompetitiveReportApprovalIDReqMultiError) AllErrors() []error { return m }

// UpdateCompetitiveReportApprovalIDReqValidationError is the validation error
// returned by UpdateCompetitiveReportApprovalIDReq.Validate if the designated
// constraints aren't met.
type UpdateCompetitiveReportApprovalIDReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateCompetitiveReportApprovalIDReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateCompetitiveReportApprovalIDReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateCompetitiveReportApprovalIDReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateCompetitiveReportApprovalIDReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateCompetitiveReportApprovalIDReqValidationError) ErrorName() string {
	return "UpdateCompetitiveReportApprovalIDReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateCompetitiveReportApprovalIDReqValidationError) 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 %sUpdateCompetitiveReportApprovalIDReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateCompetitiveReportApprovalIDReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateCompetitiveReportApprovalIDReqValidationError{}

// Validate checks the field values on CompetitiveReportLogInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CompetitiveReportLogInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CompetitiveReportLogInfo with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CompetitiveReportLogInfoMultiError, or nil if none found.
func (m *CompetitiveReportLogInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *CompetitiveReportLogInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ReportUuid

	// no validation rules for Title

	// no validation rules for UpdateTime

	// no validation rules for WorkReportStatus

	// no validation rules for ArtistName

	// no validation rules for ArtistUuid

	// no validation rules for ReportExtraData

	// no validation rules for OperatorName

	// no validation rules for OperatorID

	if len(errors) > 0 {
		return CompetitiveReportLogInfoMultiError(errors)
	}

	return nil
}

// CompetitiveReportLogInfoMultiError is an error wrapping multiple validation
// errors returned by CompetitiveReportLogInfo.ValidateAll() if the designated
// constraints aren't met.
type CompetitiveReportLogInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CompetitiveReportLogInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CompetitiveReportLogInfoMultiError) AllErrors() []error { return m }

// CompetitiveReportLogInfoValidationError is the validation error returned by
// CompetitiveReportLogInfo.Validate if the designated constraints aren't met.
type CompetitiveReportLogInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CompetitiveReportLogInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CompetitiveReportLogInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CompetitiveReportLogInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CompetitiveReportLogInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CompetitiveReportLogInfoValidationError) ErrorName() string {
	return "CompetitiveReportLogInfoValidationError"
}

// Error satisfies the builtin error interface
func (e CompetitiveReportLogInfoValidationError) 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 %sCompetitiveReportLogInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CompetitiveReportLogInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CompetitiveReportLogInfoValidationError{}

// Validate checks the field values on CompetitiveReportExtra with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CompetitiveReportExtra) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CompetitiveReportExtra with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CompetitiveReportExtraMultiError, or nil if none found.
func (m *CompetitiveReportExtra) ValidateAll() error {
	return m.validate(true)
}

func (m *CompetitiveReportExtra) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ReportUuid

	// no validation rules for ArtistConfirmedTime

	// no validation rules for CostType

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return CompetitiveReportExtraMultiError(errors)
	}

	return nil
}

// CompetitiveReportExtraMultiError is an error wrapping multiple validation
// errors returned by CompetitiveReportExtra.ValidateAll() if the designated
// constraints aren't met.
type CompetitiveReportExtraMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CompetitiveReportExtraMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CompetitiveReportExtraMultiError) AllErrors() []error { return m }

// CompetitiveReportExtraValidationError is the validation error returned by
// CompetitiveReportExtra.Validate if the designated constraints aren't met.
type CompetitiveReportExtraValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CompetitiveReportExtraValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CompetitiveReportExtraValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CompetitiveReportExtraValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CompetitiveReportExtraValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CompetitiveReportExtraValidationError) ErrorName() string {
	return "CompetitiveReportExtraValidationError"
}

// Error satisfies the builtin error interface
func (e CompetitiveReportExtraValidationError) 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 %sCompetitiveReportExtra.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CompetitiveReportExtraValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CompetitiveReportExtraValidationError{}

// Validate checks the field values on GetCompetitiveReportDetailReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetCompetitiveReportDetailReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetCompetitiveReportDetailReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// GetCompetitiveReportDetailReqMultiError, or nil if none found.
func (m *GetCompetitiveReportDetailReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetCompetitiveReportDetailReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return GetCompetitiveReportDetailReqMultiError(errors)
	}

	return nil
}

// GetCompetitiveReportDetailReqMultiError is an error wrapping multiple
// validation errors returned by GetCompetitiveReportDetailReq.ValidateAll()
// if the designated constraints aren't met.
type GetCompetitiveReportDetailReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetCompetitiveReportDetailReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetCompetitiveReportDetailReqMultiError) AllErrors() []error { return m }

// GetCompetitiveReportDetailReqValidationError is the validation error
// returned by GetCompetitiveReportDetailReq.Validate if the designated
// constraints aren't met.
type GetCompetitiveReportDetailReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetCompetitiveReportDetailReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetCompetitiveReportDetailReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetCompetitiveReportDetailReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetCompetitiveReportDetailReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetCompetitiveReportDetailReqValidationError) ErrorName() string {
	return "GetCompetitiveReportDetailReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetCompetitiveReportDetailReqValidationError) 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 %sGetCompetitiveReportDetailReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetCompetitiveReportDetailReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetCompetitiveReportDetailReqValidationError{}

// Validate checks the field values on GetCompetitiveReportForAppReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetCompetitiveReportForAppReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetCompetitiveReportForAppReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// GetCompetitiveReportForAppReqMultiError, or nil if none found.
func (m *GetCompetitiveReportForAppReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetCompetitiveReportForAppReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return GetCompetitiveReportForAppReqMultiError(errors)
	}

	return nil
}

// GetCompetitiveReportForAppReqMultiError is an error wrapping multiple
// validation errors returned by GetCompetitiveReportForAppReq.ValidateAll()
// if the designated constraints aren't met.
type GetCompetitiveReportForAppReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetCompetitiveReportForAppReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetCompetitiveReportForAppReqMultiError) AllErrors() []error { return m }

// GetCompetitiveReportForAppReqValidationError is the validation error
// returned by GetCompetitiveReportForAppReq.Validate if the designated
// constraints aren't met.
type GetCompetitiveReportForAppReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetCompetitiveReportForAppReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetCompetitiveReportForAppReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetCompetitiveReportForAppReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetCompetitiveReportForAppReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetCompetitiveReportForAppReqValidationError) ErrorName() string {
	return "GetCompetitiveReportForAppReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetCompetitiveReportForAppReqValidationError) 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 %sGetCompetitiveReportForAppReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetCompetitiveReportForAppReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetCompetitiveReportForAppReqValidationError{}

// Validate checks the field values on GetCompetitiveReportForAppResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetCompetitiveReportForAppResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetCompetitiveReportForAppResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// GetCompetitiveReportForAppRespMultiError, or nil if none found.
func (m *GetCompetitiveReportForAppResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetCompetitiveReportForAppResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SubNum

	// no validation rules for ArtistName

	// no validation rules for ReportContent

	// no validation rules for ImageUrl

	// no validation rules for Title

	// no validation rules for PdfUrl

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	if len(errors) > 0 {
		return GetCompetitiveReportForAppRespMultiError(errors)
	}

	return nil
}

// GetCompetitiveReportForAppRespMultiError is an error wrapping multiple
// validation errors returned by GetCompetitiveReportForAppResp.ValidateAll()
// if the designated constraints aren't met.
type GetCompetitiveReportForAppRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetCompetitiveReportForAppRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetCompetitiveReportForAppRespMultiError) AllErrors() []error { return m }

// GetCompetitiveReportForAppRespValidationError is the validation error
// returned by GetCompetitiveReportForAppResp.Validate if the designated
// constraints aren't met.
type GetCompetitiveReportForAppRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetCompetitiveReportForAppRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetCompetitiveReportForAppRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetCompetitiveReportForAppRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetCompetitiveReportForAppRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetCompetitiveReportForAppRespValidationError) ErrorName() string {
	return "GetCompetitiveReportForAppRespValidationError"
}

// Error satisfies the builtin error interface
func (e GetCompetitiveReportForAppRespValidationError) 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 %sGetCompetitiveReportForAppResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetCompetitiveReportForAppRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetCompetitiveReportForAppRespValidationError{}

// Validate checks the field values on GetCompetitiveReportDetailResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetCompetitiveReportDetailResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetCompetitiveReportDetailResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// GetCompetitiveReportDetailRespMultiError, or nil if none found.
func (m *GetCompetitiveReportDetailResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetCompetitiveReportDetailResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SubNum

	// no validation rules for ArtistName

	// no validation rules for ArtistID

	// no validation rules for ArtistPhone

	// no validation rules for ReportContent

	// no validation rules for ImageUrl

	// no validation rules for Title

	// no validation rules for OperatorID

	// no validation rules for OperatorName

	// no validation rules for WorkReportStatus

	// no validation rules for Reason

	// no validation rules for ComfirmType

	// no validation rules for Cost

	// no validation rules for SubmitTime

	// no validation rules for StatusUpdateTime

	// no validation rules for ApprovalID

	// no validation rules for PdfUrl

	// no validation rules for ConfirmRemark

	for idx, item := range m.GetReportLogData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, GetCompetitiveReportDetailRespValidationError{
						field:  fmt.Sprintf("ReportLogData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, GetCompetitiveReportDetailRespValidationError{
						field:  fmt.Sprintf("ReportLogData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return GetCompetitiveReportDetailRespValidationError{
					field:  fmt.Sprintf("ReportLogData[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if all {
		switch v := interface{}(m.GetExtra()).(type) {
		case interface{ ValidateAll() error }:
			if err := v.ValidateAll(); err != nil {
				errors = append(errors, GetCompetitiveReportDetailRespValidationError{
					field:  "Extra",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		case interface{ Validate() error }:
			if err := v.Validate(); err != nil {
				errors = append(errors, GetCompetitiveReportDetailRespValidationError{
					field:  "Extra",
					reason: "embedded message failed validation",
					cause:  err,
				})
			}
		}
	} else if v, ok := interface{}(m.GetExtra()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return GetCompetitiveReportDetailRespValidationError{
				field:  "Extra",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	// no validation rules for BundleOrderUuid

	if len(errors) > 0 {
		return GetCompetitiveReportDetailRespMultiError(errors)
	}

	return nil
}

// GetCompetitiveReportDetailRespMultiError is an error wrapping multiple
// validation errors returned by GetCompetitiveReportDetailResp.ValidateAll()
// if the designated constraints aren't met.
type GetCompetitiveReportDetailRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetCompetitiveReportDetailRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetCompetitiveReportDetailRespMultiError) AllErrors() []error { return m }

// GetCompetitiveReportDetailRespValidationError is the validation error
// returned by GetCompetitiveReportDetailResp.Validate if the designated
// constraints aren't met.
type GetCompetitiveReportDetailRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetCompetitiveReportDetailRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetCompetitiveReportDetailRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetCompetitiveReportDetailRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetCompetitiveReportDetailRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetCompetitiveReportDetailRespValidationError) ErrorName() string {
	return "GetCompetitiveReportDetailRespValidationError"
}

// Error satisfies the builtin error interface
func (e GetCompetitiveReportDetailRespValidationError) 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 %sGetCompetitiveReportDetailResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetCompetitiveReportDetailRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetCompetitiveReportDetailRespValidationError{}

// Validate checks the field values on ListCompetitiveReportReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListCompetitiveReportReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListCompetitiveReportReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListCompetitiveReportReqMultiError, or nil if none found.
func (m *ListCompetitiveReportReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListCompetitiveReportReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for SubNum

	// no validation rules for ArtistVal

	// no validation rules for Status

	// no validation rules for ComfirmType

	// no validation rules for StatusUpdateTimeStart

	// no validation rules for StatusUpdateTimeEnd

	// no validation rules for SubmitStartTime

	// no validation rules for SubmitEndTime

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for ArtistUuid

	if len(errors) > 0 {
		return ListCompetitiveReportReqMultiError(errors)
	}

	return nil
}

// ListCompetitiveReportReqMultiError is an error wrapping multiple validation
// errors returned by ListCompetitiveReportReq.ValidateAll() if the designated
// constraints aren't met.
type ListCompetitiveReportReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListCompetitiveReportReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListCompetitiveReportReqMultiError) AllErrors() []error { return m }

// ListCompetitiveReportReqValidationError is the validation error returned by
// ListCompetitiveReportReq.Validate if the designated constraints aren't met.
type ListCompetitiveReportReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListCompetitiveReportReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListCompetitiveReportReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListCompetitiveReportReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListCompetitiveReportReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListCompetitiveReportReqValidationError) ErrorName() string {
	return "ListCompetitiveReportReqValidationError"
}

// Error satisfies the builtin error interface
func (e ListCompetitiveReportReqValidationError) 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 %sListCompetitiveReportReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListCompetitiveReportReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListCompetitiveReportReqValidationError{}

// Validate checks the field values on CompetitiveReportInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *CompetitiveReportInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CompetitiveReportInfo with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// CompetitiveReportInfoMultiError, or nil if none found.
func (m *CompetitiveReportInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *CompetitiveReportInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for SubNum

	// no validation rules for ArtistName

	// no validation rules for ArtistID

	// no validation rules for ArtistPhone

	// no validation rules for OperatorID

	// no validation rules for OperatorName

	// no validation rules for WorkReportStatus

	// no validation rules for Reason

	// no validation rules for ComfirmType

	// no validation rules for SubmitTime

	// no validation rules for StatusUpdateTime

	// no validation rules for PdfUrl

	// no validation rules for ApprovalID

	// no validation rules for Title

	if len(errors) > 0 {
		return CompetitiveReportInfoMultiError(errors)
	}

	return nil
}

// CompetitiveReportInfoMultiError is an error wrapping multiple validation
// errors returned by CompetitiveReportInfo.ValidateAll() if the designated
// constraints aren't met.
type CompetitiveReportInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CompetitiveReportInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CompetitiveReportInfoMultiError) AllErrors() []error { return m }

// CompetitiveReportInfoValidationError is the validation error returned by
// CompetitiveReportInfo.Validate if the designated constraints aren't met.
type CompetitiveReportInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CompetitiveReportInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CompetitiveReportInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CompetitiveReportInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CompetitiveReportInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CompetitiveReportInfoValidationError) ErrorName() string {
	return "CompetitiveReportInfoValidationError"
}

// Error satisfies the builtin error interface
func (e CompetitiveReportInfoValidationError) 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 %sCompetitiveReportInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CompetitiveReportInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CompetitiveReportInfoValidationError{}

// Validate checks the field values on ListCompetitiveReportResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListCompetitiveReportResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListCompetitiveReportResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListCompetitiveReportRespMultiError, or nil if none found.
func (m *ListCompetitiveReportResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListCompetitiveReportResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListCompetitiveReportRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListCompetitiveReportRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListCompetitiveReportRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ListCompetitiveReportRespMultiError(errors)
	}

	return nil
}

// ListCompetitiveReportRespMultiError is an error wrapping multiple validation
// errors returned by ListCompetitiveReportResp.ValidateAll() if the
// designated constraints aren't met.
type ListCompetitiveReportRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListCompetitiveReportRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListCompetitiveReportRespMultiError) AllErrors() []error { return m }

// ListCompetitiveReportRespValidationError is the validation error returned by
// ListCompetitiveReportResp.Validate if the designated constraints aren't met.
type ListCompetitiveReportRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListCompetitiveReportRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListCompetitiveReportRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListCompetitiveReportRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListCompetitiveReportRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListCompetitiveReportRespValidationError) ErrorName() string {
	return "ListCompetitiveReportRespValidationError"
}

// Error satisfies the builtin error interface
func (e ListCompetitiveReportRespValidationError) 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 %sListCompetitiveReportResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListCompetitiveReportRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListCompetitiveReportRespValidationError{}

// Validate checks the field values on DeleteCompetitiveReportReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *DeleteCompetitiveReportReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DeleteCompetitiveReportReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// DeleteCompetitiveReportReqMultiError, or nil if none found.
func (m *DeleteCompetitiveReportReq) ValidateAll() error {
	return m.validate(true)
}

func (m *DeleteCompetitiveReportReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	if len(errors) > 0 {
		return DeleteCompetitiveReportReqMultiError(errors)
	}

	return nil
}

// DeleteCompetitiveReportReqMultiError is an error wrapping multiple
// validation errors returned by DeleteCompetitiveReportReq.ValidateAll() if
// the designated constraints aren't met.
type DeleteCompetitiveReportReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m DeleteCompetitiveReportReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m DeleteCompetitiveReportReqMultiError) AllErrors() []error { return m }

// DeleteCompetitiveReportReqValidationError is the validation error returned
// by DeleteCompetitiveReportReq.Validate if the designated constraints aren't met.
type DeleteCompetitiveReportReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e DeleteCompetitiveReportReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e DeleteCompetitiveReportReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e DeleteCompetitiveReportReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e DeleteCompetitiveReportReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e DeleteCompetitiveReportReqValidationError) ErrorName() string {
	return "DeleteCompetitiveReportReqValidationError"
}

// Error satisfies the builtin error interface
func (e DeleteCompetitiveReportReqValidationError) 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 %sDeleteCompetitiveReportReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = DeleteCompetitiveReportReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = DeleteCompetitiveReportReqValidationError{}

// Validate checks the field values on ImportCompetitiveReportBatchReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ImportCompetitiveReportBatchReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ImportCompetitiveReportBatchReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// ImportCompetitiveReportBatchReqMultiError, or nil if none found.
func (m *ImportCompetitiveReportBatchReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ImportCompetitiveReportBatchReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetReports() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ImportCompetitiveReportBatchReqValidationError{
						field:  fmt.Sprintf("Reports[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ImportCompetitiveReportBatchReqValidationError{
						field:  fmt.Sprintf("Reports[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ImportCompetitiveReportBatchReqValidationError{
					field:  fmt.Sprintf("Reports[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return ImportCompetitiveReportBatchReqMultiError(errors)
	}

	return nil
}

// ImportCompetitiveReportBatchReqMultiError is an error wrapping multiple
// validation errors returned by ImportCompetitiveReportBatchReq.ValidateAll()
// if the designated constraints aren't met.
type ImportCompetitiveReportBatchReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ImportCompetitiveReportBatchReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ImportCompetitiveReportBatchReqMultiError) AllErrors() []error { return m }

// ImportCompetitiveReportBatchReqValidationError is the validation error
// returned by ImportCompetitiveReportBatchReq.Validate if the designated
// constraints aren't met.
type ImportCompetitiveReportBatchReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ImportCompetitiveReportBatchReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ImportCompetitiveReportBatchReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ImportCompetitiveReportBatchReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ImportCompetitiveReportBatchReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ImportCompetitiveReportBatchReqValidationError) ErrorName() string {
	return "ImportCompetitiveReportBatchReqValidationError"
}

// Error satisfies the builtin error interface
func (e ImportCompetitiveReportBatchReqValidationError) 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 %sImportCompetitiveReportBatchReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ImportCompetitiveReportBatchReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ImportCompetitiveReportBatchReqValidationError{}

// Validate checks the field values on ImportCompetitiveReportBatchResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the first error encountered is returned, or nil if there are
// no violations.
func (m *ImportCompetitiveReportBatchResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ImportCompetitiveReportBatchResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the result is a list of violation errors wrapped in
// ImportCompetitiveReportBatchRespMultiError, or nil if none found.
func (m *ImportCompetitiveReportBatchResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ImportCompetitiveReportBatchResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetReports() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ImportCompetitiveReportBatchRespValidationError{
						field:  fmt.Sprintf("Reports[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ImportCompetitiveReportBatchRespValidationError{
						field:  fmt.Sprintf("Reports[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ImportCompetitiveReportBatchRespValidationError{
					field:  fmt.Sprintf("Reports[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for SuccessCount

	// no validation rules for FailCount

	if len(errors) > 0 {
		return ImportCompetitiveReportBatchRespMultiError(errors)
	}

	return nil
}

// ImportCompetitiveReportBatchRespMultiError is an error wrapping multiple
// validation errors returned by
// ImportCompetitiveReportBatchResp.ValidateAll() if the designated
// constraints aren't met.
type ImportCompetitiveReportBatchRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ImportCompetitiveReportBatchRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ImportCompetitiveReportBatchRespMultiError) AllErrors() []error { return m }

// ImportCompetitiveReportBatchRespValidationError is the validation error
// returned by ImportCompetitiveReportBatchResp.Validate if the designated
// constraints aren't met.
type ImportCompetitiveReportBatchRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ImportCompetitiveReportBatchRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ImportCompetitiveReportBatchRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ImportCompetitiveReportBatchRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ImportCompetitiveReportBatchRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ImportCompetitiveReportBatchRespValidationError) ErrorName() string {
	return "ImportCompetitiveReportBatchRespValidationError"
}

// Error satisfies the builtin error interface
func (e ImportCompetitiveReportBatchRespValidationError) 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 %sImportCompetitiveReportBatchResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ImportCompetitiveReportBatchRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ImportCompetitiveReportBatchRespValidationError{}

// Validate checks the field values on CountCompetitiveReportByWorkUuidsReq
// with the rules defined in the proto definition for this message. If any
// rules are violated, the first error encountered is returned, or nil if
// there are no violations.
func (m *CountCompetitiveReportByWorkUuidsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CountCompetitiveReportByWorkUuidsReq
// with the rules defined in the proto definition for this message. If any
// rules are violated, the result is a list of violation errors wrapped in
// CountCompetitiveReportByWorkUuidsReqMultiError, or nil if none found.
func (m *CountCompetitiveReportByWorkUuidsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *CountCompetitiveReportByWorkUuidsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if len(errors) > 0 {
		return CountCompetitiveReportByWorkUuidsReqMultiError(errors)
	}

	return nil
}

// CountCompetitiveReportByWorkUuidsReqMultiError is an error wrapping multiple
// validation errors returned by
// CountCompetitiveReportByWorkUuidsReq.ValidateAll() if the designated
// constraints aren't met.
type CountCompetitiveReportByWorkUuidsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CountCompetitiveReportByWorkUuidsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CountCompetitiveReportByWorkUuidsReqMultiError) AllErrors() []error { return m }

// CountCompetitiveReportByWorkUuidsReqValidationError is the validation error
// returned by CountCompetitiveReportByWorkUuidsReq.Validate if the designated
// constraints aren't met.
type CountCompetitiveReportByWorkUuidsReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CountCompetitiveReportByWorkUuidsReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CountCompetitiveReportByWorkUuidsReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CountCompetitiveReportByWorkUuidsReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CountCompetitiveReportByWorkUuidsReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CountCompetitiveReportByWorkUuidsReqValidationError) ErrorName() string {
	return "CountCompetitiveReportByWorkUuidsReqValidationError"
}

// Error satisfies the builtin error interface
func (e CountCompetitiveReportByWorkUuidsReqValidationError) 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 %sCountCompetitiveReportByWorkUuidsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CountCompetitiveReportByWorkUuidsReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CountCompetitiveReportByWorkUuidsReqValidationError{}

// Validate checks the field values on WorkUuidCount with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *WorkUuidCount) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkUuidCount with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in WorkUuidCountMultiError, or
// nil if none found.
func (m *WorkUuidCount) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkUuidCount) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for Count

	if len(errors) > 0 {
		return WorkUuidCountMultiError(errors)
	}

	return nil
}

// WorkUuidCountMultiError is an error wrapping multiple validation errors
// returned by WorkUuidCount.ValidateAll() if the designated constraints
// aren't met.
type WorkUuidCountMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkUuidCountMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkUuidCountMultiError) AllErrors() []error { return m }

// WorkUuidCountValidationError is the validation error returned by
// WorkUuidCount.Validate if the designated constraints aren't met.
type WorkUuidCountValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e WorkUuidCountValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e WorkUuidCountValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e WorkUuidCountValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e WorkUuidCountValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e WorkUuidCountValidationError) ErrorName() string { return "WorkUuidCountValidationError" }

// Error satisfies the builtin error interface
func (e WorkUuidCountValidationError) 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 %sWorkUuidCount.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkUuidCountValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = WorkUuidCountValidationError{}

// Validate checks the field values on CountCompetitiveReportByWorkUuidsResp
// with the rules defined in the proto definition for this message. If any
// rules are violated, the first error encountered is returned, or nil if
// there are no violations.
func (m *CountCompetitiveReportByWorkUuidsResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CountCompetitiveReportByWorkUuidsResp
// with the rules defined in the proto definition for this message. If any
// rules are violated, the result is a list of violation errors wrapped in
// CountCompetitiveReportByWorkUuidsRespMultiError, or nil if none found.
func (m *CountCompetitiveReportByWorkUuidsResp) ValidateAll() error {
	return m.validate(true)
}

func (m *CountCompetitiveReportByWorkUuidsResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, CountCompetitiveReportByWorkUuidsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, CountCompetitiveReportByWorkUuidsRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return CountCompetitiveReportByWorkUuidsRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	if len(errors) > 0 {
		return CountCompetitiveReportByWorkUuidsRespMultiError(errors)
	}

	return nil
}

// CountCompetitiveReportByWorkUuidsRespMultiError is an error wrapping
// multiple validation errors returned by
// CountCompetitiveReportByWorkUuidsResp.ValidateAll() if the designated
// constraints aren't met.
type CountCompetitiveReportByWorkUuidsRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m CountCompetitiveReportByWorkUuidsRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m CountCompetitiveReportByWorkUuidsRespMultiError) AllErrors() []error { return m }

// CountCompetitiveReportByWorkUuidsRespValidationError is the validation error
// returned by CountCompetitiveReportByWorkUuidsResp.Validate if the
// designated constraints aren't met.
type CountCompetitiveReportByWorkUuidsRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CountCompetitiveReportByWorkUuidsRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CountCompetitiveReportByWorkUuidsRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CountCompetitiveReportByWorkUuidsRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CountCompetitiveReportByWorkUuidsRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CountCompetitiveReportByWorkUuidsRespValidationError) ErrorName() string {
	return "CountCompetitiveReportByWorkUuidsRespValidationError"
}

// Error satisfies the builtin error interface
func (e CountCompetitiveReportByWorkUuidsRespValidationError) 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 %sCountCompetitiveReportByWorkUuidsResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CountCompetitiveReportByWorkUuidsRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CountCompetitiveReportByWorkUuidsRespValidationError{}

// Validate checks the field values on WorkResourceReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *WorkResourceReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkResourceReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkResourceReqMultiError, or nil if none found.
func (m *WorkResourceReq) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkResourceReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	if len(errors) > 0 {
		return WorkResourceReqMultiError(errors)
	}

	return nil
}

// WorkResourceReqMultiError is an error wrapping multiple validation errors
// returned by WorkResourceReq.ValidateAll() if the designated constraints
// aren't met.
type WorkResourceReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkResourceReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkResourceReqMultiError) AllErrors() []error { return m }

// WorkResourceReqValidationError is the validation error returned by
// WorkResourceReq.Validate if the designated constraints aren't met.
type WorkResourceReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e WorkResourceReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e WorkResourceReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e WorkResourceReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e WorkResourceReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e WorkResourceReqValidationError) ErrorName() string { return "WorkResourceReqValidationError" }

// Error satisfies the builtin error interface
func (e WorkResourceReqValidationError) 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 %sWorkResourceReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkResourceReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = WorkResourceReqValidationError{}

// Validate checks the field values on WorkResourceResp with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *WorkResourceResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkResourceResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkResourceRespMultiError, or nil if none found.
func (m *WorkResourceResp) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkResourceResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for ImageUrls

	// no validation rules for OldCoverUrl

	// no validation rules for NewCoverUrl

	if len(errors) > 0 {
		return WorkResourceRespMultiError(errors)
	}

	return nil
}

// WorkResourceRespMultiError is an error wrapping multiple validation errors
// returned by WorkResourceResp.ValidateAll() if the designated constraints
// aren't met.
type WorkResourceRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkResourceRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkResourceRespMultiError) AllErrors() []error { return m }

// WorkResourceRespValidationError is the validation error returned by
// WorkResourceResp.Validate if the designated constraints aren't met.
type WorkResourceRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e WorkResourceRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e WorkResourceRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e WorkResourceRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e WorkResourceRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e WorkResourceRespValidationError) ErrorName() string { return "WorkResourceRespValidationError" }

// Error satisfies the builtin error interface
func (e WorkResourceRespValidationError) 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 %sWorkResourceResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkResourceRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = WorkResourceRespValidationError{}

// Validate checks the field values on UpdateWorkResourceReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkResourceReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkResourceReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkResourceReqMultiError, or nil if none found.
func (m *UpdateWorkResourceReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkResourceReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for WorkUuid

	// no validation rules for OldCoverUrl

	// no validation rules for NewCoverUrl

	if len(errors) > 0 {
		return UpdateWorkResourceReqMultiError(errors)
	}

	return nil
}

// UpdateWorkResourceReqMultiError is an error wrapping multiple validation
// errors returned by UpdateWorkResourceReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateWorkResourceReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkResourceReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkResourceReqMultiError) AllErrors() []error { return m }

// UpdateWorkResourceReqValidationError is the validation error returned by
// UpdateWorkResourceReq.Validate if the designated constraints aren't met.
type UpdateWorkResourceReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateWorkResourceReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateWorkResourceReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateWorkResourceReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateWorkResourceReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateWorkResourceReqValidationError) ErrorName() string {
	return "UpdateWorkResourceReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateWorkResourceReqValidationError) 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 %sUpdateWorkResourceReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkResourceReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateWorkResourceReqValidationError{}

// Validate checks the field values on UpdateWorkResourceResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkResourceResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkResourceResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkResourceRespMultiError, or nil if none found.
func (m *UpdateWorkResourceResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkResourceResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	if len(errors) > 0 {
		return UpdateWorkResourceRespMultiError(errors)
	}

	return nil
}

// UpdateWorkResourceRespMultiError is an error wrapping multiple validation
// errors returned by UpdateWorkResourceResp.ValidateAll() if the designated
// constraints aren't met.
type UpdateWorkResourceRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkResourceRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkResourceRespMultiError) AllErrors() []error { return m }

// UpdateWorkResourceRespValidationError is the validation error returned by
// UpdateWorkResourceResp.Validate if the designated constraints aren't met.
type UpdateWorkResourceRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateWorkResourceRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateWorkResourceRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateWorkResourceRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateWorkResourceRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateWorkResourceRespValidationError) ErrorName() string {
	return "UpdateWorkResourceRespValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateWorkResourceRespValidationError) 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 %sUpdateWorkResourceResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkResourceRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateWorkResourceRespValidationError{}

// Validate checks the field values on UpdateMediaAccStatusReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateMediaAccStatusReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateMediaAccStatusReq with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateMediaAccStatusReqMultiError, or nil if none found.
func (m *UpdateMediaAccStatusReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateMediaAccStatusReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for PlatformID

	// no validation rules for InfoResp

	if len(errors) > 0 {
		return UpdateMediaAccStatusReqMultiError(errors)
	}

	return nil
}

// UpdateMediaAccStatusReqMultiError is an error wrapping multiple validation
// errors returned by UpdateMediaAccStatusReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateMediaAccStatusReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateMediaAccStatusReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateMediaAccStatusReqMultiError) AllErrors() []error { return m }

// UpdateMediaAccStatusReqValidationError is the validation error returned by
// UpdateMediaAccStatusReq.Validate if the designated constraints aren't met.
type UpdateMediaAccStatusReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateMediaAccStatusReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateMediaAccStatusReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateMediaAccStatusReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateMediaAccStatusReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateMediaAccStatusReqValidationError) ErrorName() string {
	return "UpdateMediaAccStatusReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateMediaAccStatusReqValidationError) 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 %sUpdateMediaAccStatusReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateMediaAccStatusReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateMediaAccStatusReqValidationError{}

// Validate checks the field values on UpdateMediaAccStatusResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateMediaAccStatusResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateMediaAccStatusResp with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateMediaAccStatusRespMultiError, or nil if none found.
func (m *UpdateMediaAccStatusResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateMediaAccStatusResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ExceptionStatus

	// no validation rules for MediaAccUserID

	if len(errors) > 0 {
		return UpdateMediaAccStatusRespMultiError(errors)
	}

	return nil
}

// UpdateMediaAccStatusRespMultiError is an error wrapping multiple validation
// errors returned by UpdateMediaAccStatusResp.ValidateAll() if the designated
// constraints aren't met.
type UpdateMediaAccStatusRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateMediaAccStatusRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateMediaAccStatusRespMultiError) AllErrors() []error { return m }

// UpdateMediaAccStatusRespValidationError is the validation error returned by
// UpdateMediaAccStatusResp.Validate if the designated constraints aren't met.
type UpdateMediaAccStatusRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateMediaAccStatusRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateMediaAccStatusRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateMediaAccStatusRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateMediaAccStatusRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateMediaAccStatusRespValidationError) ErrorName() string {
	return "UpdateMediaAccStatusRespValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateMediaAccStatusRespValidationError) 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 %sUpdateMediaAccStatusResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateMediaAccStatusRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateMediaAccStatusRespValidationError{}

// Validate checks the field values on UpdateWorkScriptReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateWorkScriptReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateWorkScriptReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateWorkScriptReqMultiError, or nil if none found.
func (m *UpdateWorkScriptReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateWorkScriptReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for ScriptUuid

	if len(errors) > 0 {
		return UpdateWorkScriptReqMultiError(errors)
	}

	return nil
}

// UpdateWorkScriptReqMultiError is an error wrapping multiple validation
// errors returned by UpdateWorkScriptReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateWorkScriptReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateWorkScriptReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateWorkScriptReqMultiError) AllErrors() []error { return m }

// UpdateWorkScriptReqValidationError is the validation error returned by
// UpdateWorkScriptReq.Validate if the designated constraints aren't met.
type UpdateWorkScriptReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateWorkScriptReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateWorkScriptReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateWorkScriptReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateWorkScriptReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateWorkScriptReqValidationError) ErrorName() string {
	return "UpdateWorkScriptReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateWorkScriptReqValidationError) 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 %sUpdateWorkScriptReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateWorkScriptReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateWorkScriptReqValidationError{}

// Validate checks the field values on UnbindMediaAuthReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UnbindMediaAuthReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UnbindMediaAuthReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UnbindMediaAuthReqMultiError, or nil if none found.
func (m *UnbindMediaAuthReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UnbindMediaAuthReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for MediaAccountUuid

	// no validation rules for Remark

	if len(errors) > 0 {
		return UnbindMediaAuthReqMultiError(errors)
	}

	return nil
}

// UnbindMediaAuthReqMultiError is an error wrapping multiple validation errors
// returned by UnbindMediaAuthReq.ValidateAll() if the designated constraints
// aren't met.
type UnbindMediaAuthReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UnbindMediaAuthReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UnbindMediaAuthReqMultiError) AllErrors() []error { return m }

// UnbindMediaAuthReqValidationError is the validation error returned by
// UnbindMediaAuthReq.Validate if the designated constraints aren't met.
type UnbindMediaAuthReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UnbindMediaAuthReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UnbindMediaAuthReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UnbindMediaAuthReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UnbindMediaAuthReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UnbindMediaAuthReqValidationError) ErrorName() string {
	return "UnbindMediaAuthReqValidationError"
}

// Error satisfies the builtin error interface
func (e UnbindMediaAuthReqValidationError) 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 %sUnbindMediaAuthReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UnbindMediaAuthReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UnbindMediaAuthReqValidationError{}

// Validate checks the field values on UnbindMediaAuthResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UnbindMediaAuthResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UnbindMediaAuthResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UnbindMediaAuthRespMultiError, or nil if none found.
func (m *UnbindMediaAuthResp) ValidateAll() error {
	return m.validate(true)
}

func (m *UnbindMediaAuthResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Success

	// no validation rules for Message

	if len(errors) > 0 {
		return UnbindMediaAuthRespMultiError(errors)
	}

	return nil
}

// UnbindMediaAuthRespMultiError is an error wrapping multiple validation
// errors returned by UnbindMediaAuthResp.ValidateAll() if the designated
// constraints aren't met.
type UnbindMediaAuthRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UnbindMediaAuthRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UnbindMediaAuthRespMultiError) AllErrors() []error { return m }

// UnbindMediaAuthRespValidationError is the validation error returned by
// UnbindMediaAuthResp.Validate if the designated constraints aren't met.
type UnbindMediaAuthRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UnbindMediaAuthRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UnbindMediaAuthRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UnbindMediaAuthRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UnbindMediaAuthRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UnbindMediaAuthRespValidationError) ErrorName() string {
	return "UnbindMediaAuthRespValidationError"
}

// Error satisfies the builtin error interface
func (e UnbindMediaAuthRespValidationError) 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 %sUnbindMediaAuthResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UnbindMediaAuthRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UnbindMediaAuthRespValidationError{}

// Validate checks the field values on UpdateMediaAccInfoReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateMediaAccInfoReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateMediaAccInfoReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateMediaAccInfoReqMultiError, or nil if none found.
func (m *UpdateMediaAccInfoReq) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateMediaAccInfoReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for MediaAccountUuid

	// no validation rules for ExceptionStatus

	// no validation rules for Expired

	// no validation rules for ExpiredSource

	// no validation rules for Remark

	// no validation rules for AuthStatus

	if len(errors) > 0 {
		return UpdateMediaAccInfoReqMultiError(errors)
	}

	return nil
}

// UpdateMediaAccInfoReqMultiError is an error wrapping multiple validation
// errors returned by UpdateMediaAccInfoReq.ValidateAll() if the designated
// constraints aren't met.
type UpdateMediaAccInfoReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateMediaAccInfoReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateMediaAccInfoReqMultiError) AllErrors() []error { return m }

// UpdateMediaAccInfoReqValidationError is the validation error returned by
// UpdateMediaAccInfoReq.Validate if the designated constraints aren't met.
type UpdateMediaAccInfoReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateMediaAccInfoReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateMediaAccInfoReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateMediaAccInfoReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateMediaAccInfoReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateMediaAccInfoReqValidationError) ErrorName() string {
	return "UpdateMediaAccInfoReqValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateMediaAccInfoReqValidationError) 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 %sUpdateMediaAccInfoReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateMediaAccInfoReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateMediaAccInfoReqValidationError{}

// Validate checks the field values on PublishLogInfo with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.
func (m *PublishLogInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PublishLogInfo with the rules defined
// in the proto definition for this message. If any rules are violated, the
// result is a list of violation errors wrapped in PublishLogInfoMultiError,
// or nil if none found.
func (m *PublishLogInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *PublishLogInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for Uuid

	// no validation rules for WorkUuid

	// no validation rules for Title

	// no validation rules for PlatformID

	// no validation rules for PublishMediaID

	// no validation rules for PublishMediaStatus

	// no validation rules for PublishSource

	// no validation rules for Action

	// no validation rules for Detail

	// no validation rules for ArtistUuid

	// no validation rules for ArtistSubNum

	// no validation rules for CreatedAt

	// no validation rules for UpdatedAt

	// no validation rules for WorkCategory

	// no validation rules for ArtistName

	if len(errors) > 0 {
		return PublishLogInfoMultiError(errors)
	}

	return nil
}

// PublishLogInfoMultiError is an error wrapping multiple validation errors
// returned by PublishLogInfo.ValidateAll() if the designated constraints
// aren't met.
type PublishLogInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m PublishLogInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m PublishLogInfoMultiError) AllErrors() []error { return m }

// PublishLogInfoValidationError is the validation error returned by
// PublishLogInfo.Validate if the designated constraints aren't met.
type PublishLogInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e PublishLogInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e PublishLogInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e PublishLogInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e PublishLogInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e PublishLogInfoValidationError) ErrorName() string { return "PublishLogInfoValidationError" }

// Error satisfies the builtin error interface
func (e PublishLogInfoValidationError) 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 %sPublishLogInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PublishLogInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = PublishLogInfoValidationError{}

// Validate checks the field values on ListPublishLogReq with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *ListPublishLogReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListPublishLogReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListPublishLogReqMultiError, or nil if none found.
func (m *ListPublishLogReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ListPublishLogReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for ArtistUuid

	// no validation rules for PlatformID

	// no validation rules for PublishMediaStatus

	// no validation rules for PublishSource

	// no validation rules for PublishStartTime

	// no validation rules for PublishEndTime

	// no validation rules for Page

	// no validation rules for PageSize

	// no validation rules for ArtistSubNum

	// no validation rules for ArtistKeyword

	// no validation rules for Title

	// no validation rules for WorkCategory

	if len(errors) > 0 {
		return ListPublishLogReqMultiError(errors)
	}

	return nil
}

// ListPublishLogReqMultiError is an error wrapping multiple validation errors
// returned by ListPublishLogReq.ValidateAll() if the designated constraints
// aren't met.
type ListPublishLogReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListPublishLogReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListPublishLogReqMultiError) AllErrors() []error { return m }

// ListPublishLogReqValidationError is the validation error returned by
// ListPublishLogReq.Validate if the designated constraints aren't met.
type ListPublishLogReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListPublishLogReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListPublishLogReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListPublishLogReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListPublishLogReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListPublishLogReqValidationError) ErrorName() string {
	return "ListPublishLogReqValidationError"
}

// Error satisfies the builtin error interface
func (e ListPublishLogReqValidationError) 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 %sListPublishLogReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListPublishLogReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListPublishLogReqValidationError{}

// Validate checks the field values on ListPublishLogResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *ListPublishLogResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ListPublishLogResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// ListPublishLogRespMultiError, or nil if none found.
func (m *ListPublishLogResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ListPublishLogResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	for idx, item := range m.GetData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ListPublishLogRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ListPublishLogRespValidationError{
						field:  fmt.Sprintf("Data[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return ListPublishLogRespValidationError{
					field:  fmt.Sprintf("Data[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for Count

	if len(errors) > 0 {
		return ListPublishLogRespMultiError(errors)
	}

	return nil
}

// ListPublishLogRespMultiError is an error wrapping multiple validation errors
// returned by ListPublishLogResp.ValidateAll() if the designated constraints
// aren't met.
type ListPublishLogRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ListPublishLogRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ListPublishLogRespMultiError) AllErrors() []error { return m }

// ListPublishLogRespValidationError is the validation error returned by
// ListPublishLogResp.Validate if the designated constraints aren't met.
type ListPublishLogRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ListPublishLogRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ListPublishLogRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ListPublishLogRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ListPublishLogRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ListPublishLogRespValidationError) ErrorName() string {
	return "ListPublishLogRespValidationError"
}

// Error satisfies the builtin error interface
func (e ListPublishLogRespValidationError) 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 %sListPublishLogResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ListPublishLogRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ListPublishLogRespValidationError{}

// Validate checks the field values on GetArtistWorkStatsReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetArtistWorkStatsReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetArtistWorkStatsReq with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetArtistWorkStatsReqMultiError, or nil if none found.
func (m *GetArtistWorkStatsReq) ValidateAll() error {
	return m.validate(true)
}

func (m *GetArtistWorkStatsReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for StatusUpdateTime

	if len(errors) > 0 {
		return GetArtistWorkStatsReqMultiError(errors)
	}

	return nil
}

// GetArtistWorkStatsReqMultiError is an error wrapping multiple validation
// errors returned by GetArtistWorkStatsReq.ValidateAll() if the designated
// constraints aren't met.
type GetArtistWorkStatsReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetArtistWorkStatsReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetArtistWorkStatsReqMultiError) AllErrors() []error { return m }

// GetArtistWorkStatsReqValidationError is the validation error returned by
// GetArtistWorkStatsReq.Validate if the designated constraints aren't met.
type GetArtistWorkStatsReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetArtistWorkStatsReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetArtistWorkStatsReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetArtistWorkStatsReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetArtistWorkStatsReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetArtistWorkStatsReqValidationError) ErrorName() string {
	return "GetArtistWorkStatsReqValidationError"
}

// Error satisfies the builtin error interface
func (e GetArtistWorkStatsReqValidationError) 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 %sGetArtistWorkStatsReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetArtistWorkStatsReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetArtistWorkStatsReqValidationError{}

// Validate checks the field values on GetArtistWorkStatsResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *GetArtistWorkStatsResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on GetArtistWorkStatsResp with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// GetArtistWorkStatsRespMultiError, or nil if none found.
func (m *GetArtistWorkStatsResp) ValidateAll() error {
	return m.validate(true)
}

func (m *GetArtistWorkStatsResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for VideoCount

	// no validation rules for ImageCount

	// no validation rules for AccountCount

	if len(errors) > 0 {
		return GetArtistWorkStatsRespMultiError(errors)
	}

	return nil
}

// GetArtistWorkStatsRespMultiError is an error wrapping multiple validation
// errors returned by GetArtistWorkStatsResp.ValidateAll() if the designated
// constraints aren't met.
type GetArtistWorkStatsRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m GetArtistWorkStatsRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m GetArtistWorkStatsRespMultiError) AllErrors() []error { return m }

// GetArtistWorkStatsRespValidationError is the validation error returned by
// GetArtistWorkStatsResp.Validate if the designated constraints aren't met.
type GetArtistWorkStatsRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e GetArtistWorkStatsRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e GetArtistWorkStatsRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e GetArtistWorkStatsRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e GetArtistWorkStatsRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e GetArtistWorkStatsRespValidationError) ErrorName() string {
	return "GetArtistWorkStatsRespValidationError"
}

// Error satisfies the builtin error interface
func (e GetArtistWorkStatsRespValidationError) 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 %sGetArtistWorkStatsResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = GetArtistWorkStatsRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = GetArtistWorkStatsRespValidationError{}

// Validate checks the field values on ImportCompetitiveReportHistoryReq with
// the rules defined in the proto definition for this message. If any rules
// are violated, the first error encountered is returned, or nil if there are
// no violations.
func (m *ImportCompetitiveReportHistoryReq) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ImportCompetitiveReportHistoryReq
// with the rules defined in the proto definition for this message. If any
// rules are violated, the result is a list of violation errors wrapped in
// ImportCompetitiveReportHistoryReqMultiError, or nil if none found.
func (m *ImportCompetitiveReportHistoryReq) ValidateAll() error {
	return m.validate(true)
}

func (m *ImportCompetitiveReportHistoryReq) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ReportUuid

	// no validation rules for SubmitTime

	// no validation rules for Title

	// no validation rules for ConfirmType

	if len(errors) > 0 {
		return ImportCompetitiveReportHistoryReqMultiError(errors)
	}

	return nil
}

// ImportCompetitiveReportHistoryReqMultiError is an error wrapping multiple
// validation errors returned by
// ImportCompetitiveReportHistoryReq.ValidateAll() if the designated
// constraints aren't met.
type ImportCompetitiveReportHistoryReqMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ImportCompetitiveReportHistoryReqMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ImportCompetitiveReportHistoryReqMultiError) AllErrors() []error { return m }

// ImportCompetitiveReportHistoryReqValidationError is the validation error
// returned by ImportCompetitiveReportHistoryReq.Validate if the designated
// constraints aren't met.
type ImportCompetitiveReportHistoryReqValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ImportCompetitiveReportHistoryReqValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ImportCompetitiveReportHistoryReqValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ImportCompetitiveReportHistoryReqValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ImportCompetitiveReportHistoryReqValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ImportCompetitiveReportHistoryReqValidationError) ErrorName() string {
	return "ImportCompetitiveReportHistoryReqValidationError"
}

// Error satisfies the builtin error interface
func (e ImportCompetitiveReportHistoryReqValidationError) 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 %sImportCompetitiveReportHistoryReq.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ImportCompetitiveReportHistoryReqValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ImportCompetitiveReportHistoryReqValidationError{}

// Validate checks the field values on ImportCompetitiveReportHistoryResp with
// the rules defined in the proto definition for this message. If any rules
// are violated, the first error encountered is returned, or nil if there are
// no violations.
func (m *ImportCompetitiveReportHistoryResp) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ImportCompetitiveReportHistoryResp
// with the rules defined in the proto definition for this message. If any
// rules are violated, the result is a list of violation errors wrapped in
// ImportCompetitiveReportHistoryRespMultiError, or nil if none found.
func (m *ImportCompetitiveReportHistoryResp) ValidateAll() error {
	return m.validate(true)
}

func (m *ImportCompetitiveReportHistoryResp) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ReportUuid

	if len(errors) > 0 {
		return ImportCompetitiveReportHistoryRespMultiError(errors)
	}

	return nil
}

// ImportCompetitiveReportHistoryRespMultiError is an error wrapping multiple
// validation errors returned by
// ImportCompetitiveReportHistoryResp.ValidateAll() if the designated
// constraints aren't met.
type ImportCompetitiveReportHistoryRespMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m ImportCompetitiveReportHistoryRespMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m ImportCompetitiveReportHistoryRespMultiError) AllErrors() []error { return m }

// ImportCompetitiveReportHistoryRespValidationError is the validation error
// returned by ImportCompetitiveReportHistoryResp.Validate if the designated
// constraints aren't met.
type ImportCompetitiveReportHistoryRespValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ImportCompetitiveReportHistoryRespValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ImportCompetitiveReportHistoryRespValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ImportCompetitiveReportHistoryRespValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ImportCompetitiveReportHistoryRespValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ImportCompetitiveReportHistoryRespValidationError) ErrorName() string {
	return "ImportCompetitiveReportHistoryRespValidationError"
}

// Error satisfies the builtin error interface
func (e ImportCompetitiveReportHistoryRespValidationError) 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 %sImportCompetitiveReportHistoryResp.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ImportCompetitiveReportHistoryRespValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ImportCompetitiveReportHistoryRespValidationError{}

// Validate checks the field values on WorkListResp_Info with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *WorkListResp_Info) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkListResp_Info with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkListResp_InfoMultiError, or nil if none found.
func (m *WorkListResp_Info) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkListResp_Info) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for ArtistName

	// no validation rules for ArtistPhone

	// no validation rules for Title

	// no validation rules for WorkCategory

	// no validation rules for WorkStatus

	// no validation rules for SubmitTime

	// no validation rules for StatusUpdateTime

	// no validation rules for ApprovalID

	// no validation rules for CostType

	// no validation rules for ScriptUuid

	// no validation rules for ScriptTitle

	// no validation rules for ArtistSubNum

	// no validation rules for TiktokStatus

	// no validation rules for InsStatus

	// no validation rules for DmStatus

	// no validation rules for ConfirmType

	// no validation rules for Remark

	// no validation rules for Status1Time

	// no validation rules for Status4Time

	// no validation rules for Status9Time

	// no validation rules for Status6Time

	// no validation rules for PublishMediaIDs

	// no validation rules for YoutubeStatus

	// no validation rules for BlueskyStatus

	if len(errors) > 0 {
		return WorkListResp_InfoMultiError(errors)
	}

	return nil
}

// WorkListResp_InfoMultiError is an error wrapping multiple validation errors
// returned by WorkListResp_Info.ValidateAll() if the designated constraints
// aren't met.
type WorkListResp_InfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkListResp_InfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkListResp_InfoMultiError) AllErrors() []error { return m }

// WorkListResp_InfoValidationError is the validation error returned by
// WorkListResp_Info.Validate if the designated constraints aren't met.
type WorkListResp_InfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e WorkListResp_InfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e WorkListResp_InfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e WorkListResp_InfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e WorkListResp_InfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e WorkListResp_InfoValidationError) ErrorName() string {
	return "WorkListResp_InfoValidationError"
}

// Error satisfies the builtin error interface
func (e WorkListResp_InfoValidationError) 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 %sWorkListResp_Info.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkListResp_InfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = WorkListResp_InfoValidationError{}

// Validate checks the field values on MediaAccountsResp_Info with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *MediaAccountsResp_Info) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaAccountsResp_Info with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaAccountsResp_InfoMultiError, or nil if none found.
func (m *MediaAccountsResp_Info) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaAccountsResp_Info) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PlatformID

	// no validation rules for FansCount

	// no validation rules for WorkCount

	// no validation rules for ArtistUuid

	// no validation rules for MediaAccountUuid

	// no validation rules for MediaAccountName

	// no validation rules for Expired

	// no validation rules for LastOrderUuid

	if len(errors) > 0 {
		return MediaAccountsResp_InfoMultiError(errors)
	}

	return nil
}

// MediaAccountsResp_InfoMultiError is an error wrapping multiple validation
// errors returned by MediaAccountsResp_Info.ValidateAll() if the designated
// constraints aren't met.
type MediaAccountsResp_InfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaAccountsResp_InfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaAccountsResp_InfoMultiError) AllErrors() []error { return m }

// MediaAccountsResp_InfoValidationError is the validation error returned by
// MediaAccountsResp_Info.Validate if the designated constraints aren't met.
type MediaAccountsResp_InfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MediaAccountsResp_InfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MediaAccountsResp_InfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MediaAccountsResp_InfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MediaAccountsResp_InfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MediaAccountsResp_InfoValidationError) ErrorName() string {
	return "MediaAccountsResp_InfoValidationError"
}

// Error satisfies the builtin error interface
func (e MediaAccountsResp_InfoValidationError) 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 %sMediaAccountsResp_Info.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaAccountsResp_InfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MediaAccountsResp_InfoValidationError{}

// Validate checks the field values on MediaWorksResp_Info with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *MediaWorksResp_Info) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaWorksResp_Info with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// MediaWorksResp_InfoMultiError, or nil if none found.
func (m *MediaWorksResp_Info) ValidateAll() error {
	return m.validate(true)
}

func (m *MediaWorksResp_Info) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for Title

	// no validation rules for Content

	// no validation rules for WorkCategory

	// no validation rules for WorkStatus

	// no validation rules for SubmitTime

	// no validation rules for StatusUpdateTime

	// no validation rules for VideoUrl

	// no validation rules for CoverUrl

	if len(errors) > 0 {
		return MediaWorksResp_InfoMultiError(errors)
	}

	return nil
}

// MediaWorksResp_InfoMultiError is an error wrapping multiple validation
// errors returned by MediaWorksResp_Info.ValidateAll() if the designated
// constraints aren't met.
type MediaWorksResp_InfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m MediaWorksResp_InfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m MediaWorksResp_InfoMultiError) AllErrors() []error { return m }

// MediaWorksResp_InfoValidationError is the validation error returned by
// MediaWorksResp_Info.Validate if the designated constraints aren't met.
type MediaWorksResp_InfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MediaWorksResp_InfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MediaWorksResp_InfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MediaWorksResp_InfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MediaWorksResp_InfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MediaWorksResp_InfoValidationError) ErrorName() string {
	return "MediaWorksResp_InfoValidationError"
}

// Error satisfies the builtin error interface
func (e MediaWorksResp_InfoValidationError) 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 %sMediaWorksResp_Info.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MediaWorksResp_InfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MediaWorksResp_InfoValidationError{}

// Validate checks the field values on PublishResp_Info with the rules defined
// in the proto definition for this message. If any rules are violated, the
// first error encountered is returned, or nil if there are no violations.
func (m *PublishResp_Info) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PublishResp_Info with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// PublishResp_InfoMultiError, or nil if none found.
func (m *PublishResp_Info) ValidateAll() error {
	return m.validate(true)
}

func (m *PublishResp_Info) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for WorkCategory

	if len(errors) > 0 {
		return PublishResp_InfoMultiError(errors)
	}

	return nil
}

// PublishResp_InfoMultiError is an error wrapping multiple validation errors
// returned by PublishResp_Info.ValidateAll() if the designated constraints
// aren't met.
type PublishResp_InfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m PublishResp_InfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m PublishResp_InfoMultiError) AllErrors() []error { return m }

// PublishResp_InfoValidationError is the validation error returned by
// PublishResp_Info.Validate if the designated constraints aren't met.
type PublishResp_InfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e PublishResp_InfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e PublishResp_InfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e PublishResp_InfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e PublishResp_InfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e PublishResp_InfoValidationError) ErrorName() string { return "PublishResp_InfoValidationError" }

// Error satisfies the builtin error interface
func (e PublishResp_InfoValidationError) 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 %sPublishResp_Info.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PublishResp_InfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = PublishResp_InfoValidationError{}

// Validate checks the field values on WorkListPublishedResp_Info with the
// rules defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *WorkListPublishedResp_Info) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on WorkListPublishedResp_Info with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// WorkListPublishedResp_InfoMultiError, or nil if none found.
func (m *WorkListPublishedResp_Info) ValidateAll() error {
	return m.validate(true)
}

func (m *WorkListPublishedResp_Info) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	// no validation rules for ArtistUuid

	// no validation rules for ArtistName

	// no validation rules for Title

	// no validation rules for Content

	// no validation rules for WorkCategory

	// no validation rules for StatusUpdateTime

	// no validation rules for VideoUrl

	// no validation rules for CoverUrl

	// no validation rules for CoverTimestampMs

	// no validation rules for Count

	// no validation rules for ViewsCount

	// no validation rules for LikesCount

	// no validation rules for CommentsCount

	// no validation rules for SharesCount

	// no validation rules for PublishTime

	if len(errors) > 0 {
		return WorkListPublishedResp_InfoMultiError(errors)
	}

	return nil
}

// WorkListPublishedResp_InfoMultiError is an error wrapping multiple
// validation errors returned by WorkListPublishedResp_Info.ValidateAll() if
// the designated constraints aren't met.
type WorkListPublishedResp_InfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m WorkListPublishedResp_InfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m WorkListPublishedResp_InfoMultiError) AllErrors() []error { return m }

// WorkListPublishedResp_InfoValidationError is the validation error returned
// by WorkListPublishedResp_Info.Validate if the designated constraints aren't met.
type WorkListPublishedResp_InfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e WorkListPublishedResp_InfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e WorkListPublishedResp_InfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e WorkListPublishedResp_InfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e WorkListPublishedResp_InfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e WorkListPublishedResp_InfoValidationError) ErrorName() string {
	return "WorkListPublishedResp_InfoValidationError"
}

// Error satisfies the builtin error interface
func (e WorkListPublishedResp_InfoValidationError) 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 %sWorkListPublishedResp_Info.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WorkListPublishedResp_InfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = WorkListPublishedResp_InfoValidationError{}

// Validate checks the field values on RefreshWorkListResp_Info with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *RefreshWorkListResp_Info) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RefreshWorkListResp_Info with the
// rules defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// RefreshWorkListResp_InfoMultiError, or nil if none found.
func (m *RefreshWorkListResp_Info) ValidateAll() error {
	return m.validate(true)
}

func (m *RefreshWorkListResp_Info) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for WorkUuid

	for idx, item := range m.GetPlatformInfoData() {
		_, _ = idx, item

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, RefreshWorkListResp_InfoValidationError{
						field:  fmt.Sprintf("PlatformInfoData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, RefreshWorkListResp_InfoValidationError{
						field:  fmt.Sprintf("PlatformInfoData[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			}
		} else if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return RefreshWorkListResp_InfoValidationError{
					field:  fmt.Sprintf("PlatformInfoData[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	// no validation rules for ProfileKey

	if len(errors) > 0 {
		return RefreshWorkListResp_InfoMultiError(errors)
	}

	return nil
}

// RefreshWorkListResp_InfoMultiError is an error wrapping multiple validation
// errors returned by RefreshWorkListResp_Info.ValidateAll() if the designated
// constraints aren't met.
type RefreshWorkListResp_InfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m RefreshWorkListResp_InfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m RefreshWorkListResp_InfoMultiError) AllErrors() []error { return m }

// RefreshWorkListResp_InfoValidationError is the validation error returned by
// RefreshWorkListResp_Info.Validate if the designated constraints aren't met.
type RefreshWorkListResp_InfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e RefreshWorkListResp_InfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e RefreshWorkListResp_InfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e RefreshWorkListResp_InfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e RefreshWorkListResp_InfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e RefreshWorkListResp_InfoValidationError) ErrorName() string {
	return "RefreshWorkListResp_InfoValidationError"
}

// Error satisfies the builtin error interface
func (e RefreshWorkListResp_InfoValidationError) 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 %sRefreshWorkListResp_Info.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RefreshWorkListResp_InfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = RefreshWorkListResp_InfoValidationError{}

// Validate checks the field values on RefreshWorkListResp_Info_PlatformInfo
// with the rules defined in the proto definition for this message. If any
// rules are violated, the first error encountered is returned, or nil if
// there are no violations.
func (m *RefreshWorkListResp_Info_PlatformInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RefreshWorkListResp_Info_PlatformInfo
// with the rules defined in the proto definition for this message. If any
// rules are violated, the result is a list of violation errors wrapped in
// RefreshWorkListResp_Info_PlatformInfoMultiError, or nil if none found.
func (m *RefreshWorkListResp_Info_PlatformInfo) ValidateAll() error {
	return m.validate(true)
}

func (m *RefreshWorkListResp_Info_PlatformInfo) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for PublishMediaID

	// no validation rules for PlatformID

	// no validation rules for PublishMediaStatus

	// no validation rules for MediaUserID

	// no validation rules for PlatformUuid

	// no validation rules for Token

	if len(errors) > 0 {
		return RefreshWorkListResp_Info_PlatformInfoMultiError(errors)
	}

	return nil
}

// RefreshWorkListResp_Info_PlatformInfoMultiError is an error wrapping
// multiple validation errors returned by
// RefreshWorkListResp_Info_PlatformInfo.ValidateAll() if the designated
// constraints aren't met.
type RefreshWorkListResp_Info_PlatformInfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m RefreshWorkListResp_Info_PlatformInfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m RefreshWorkListResp_Info_PlatformInfoMultiError) AllErrors() []error { return m }

// RefreshWorkListResp_Info_PlatformInfoValidationError is the validation error
// returned by RefreshWorkListResp_Info_PlatformInfo.Validate if the
// designated constraints aren't met.
type RefreshWorkListResp_Info_PlatformInfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e RefreshWorkListResp_Info_PlatformInfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e RefreshWorkListResp_Info_PlatformInfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e RefreshWorkListResp_Info_PlatformInfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e RefreshWorkListResp_Info_PlatformInfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e RefreshWorkListResp_Info_PlatformInfoValidationError) ErrorName() string {
	return "RefreshWorkListResp_Info_PlatformInfoValidationError"
}

// Error satisfies the builtin error interface
func (e RefreshWorkListResp_Info_PlatformInfoValidationError) 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 %sRefreshWorkListResp_Info_PlatformInfo.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RefreshWorkListResp_Info_PlatformInfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = RefreshWorkListResp_Info_PlatformInfoValidationError{}

// Validate checks the field values on UpdateOAuthReq_Info with the rules
// defined in the proto definition for this message. If any rules are
// violated, the first error encountered is returned, or nil if there are no violations.
func (m *UpdateOAuthReq_Info) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on UpdateOAuthReq_Info with the rules
// defined in the proto definition for this message. If any rules are
// violated, the result is a list of violation errors wrapped in
// UpdateOAuthReq_InfoMultiError, or nil if none found.
func (m *UpdateOAuthReq_Info) ValidateAll() error {
	return m.validate(true)
}

func (m *UpdateOAuthReq_Info) validate(all bool) error {
	if m == nil {
		return nil
	}

	var errors []error

	// no validation rules for ArtistUuid

	// no validation rules for PlatformID

	// no validation rules for AsID

	// no validation rules for PlatformUserName

	// no validation rules for AutInfo

	if len(errors) > 0 {
		return UpdateOAuthReq_InfoMultiError(errors)
	}

	return nil
}

// UpdateOAuthReq_InfoMultiError is an error wrapping multiple validation
// errors returned by UpdateOAuthReq_Info.ValidateAll() if the designated
// constraints aren't met.
type UpdateOAuthReq_InfoMultiError []error

// Error returns a concatenation of all the error messages it wraps.
func (m UpdateOAuthReq_InfoMultiError) Error() string {
	var msgs []string
	for _, err := range m {
		msgs = append(msgs, err.Error())
	}
	return strings.Join(msgs, "; ")
}

// AllErrors returns a list of validation violation errors.
func (m UpdateOAuthReq_InfoMultiError) AllErrors() []error { return m }

// UpdateOAuthReq_InfoValidationError is the validation error returned by
// UpdateOAuthReq_Info.Validate if the designated constraints aren't met.
type UpdateOAuthReq_InfoValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e UpdateOAuthReq_InfoValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e UpdateOAuthReq_InfoValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e UpdateOAuthReq_InfoValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e UpdateOAuthReq_InfoValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e UpdateOAuthReq_InfoValidationError) ErrorName() string {
	return "UpdateOAuthReq_InfoValidationError"
}

// Error satisfies the builtin error interface
func (e UpdateOAuthReq_InfoValidationError) 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 %sUpdateOAuthReq_Info.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = UpdateOAuthReq_InfoValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = UpdateOAuthReq_InfoValidationError{}
