active_archive.pb.validate.go

// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: active_archive.proto

package v1

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 LibraryManagerResourceKey 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 *LibraryManagerResourceKey) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on LibraryManagerResourceKey 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
// LibraryManagerResourceKeyMultiError, or nil if none found.
func (m *LibraryManagerResourceKey) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Name

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

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m LibraryManagerResourceKeyMultiError) 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 LibraryManagerResourceKeyMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = LibraryManagerResourceKeyValidationError{}

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

// Validate checks the field values on MediaInfoReply 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 *MediaInfoReply) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediaInfoReply 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 MediaInfoReplyMultiError,
// or nil if none found.
func (m *MediaInfoReply) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m MediaInfoReplyMultiError) 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 MediaInfoReplyMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = MediaInfoReplyValidationError{}

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

// Validate checks the field values on CreatePoolParams 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 *CreatePoolParams) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on CreatePoolParams 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
// CreatePoolParamsMultiError, or nil if none found.
func (m *CreatePoolParams) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Name

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

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m CreatePoolParamsMultiError) 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 CreatePoolParamsMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = CreatePoolParamsValidationError{}

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

// Validate checks the field values on PoolAddRequest 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 *PoolAddRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PoolAddRequest 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 PoolAddRequestMultiError,
// or nil if none found.
func (m *PoolAddRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

	// no validation rules for Key

	// no validation rules for FormatTape

	// no validation rules for PerformCheck

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m PoolAddRequestMultiError) 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 PoolAddRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = PoolAddRequestValidationError{}

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

// Validate checks the field values on PoolRemoveRequest 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 *PoolRemoveRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PoolRemoveRequest 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
// PoolRemoveRequestMultiError, or nil if none found.
func (m *PoolRemoveRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

	// no validation rules for Key

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m PoolRemoveRequestMultiError) 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 PoolRemoveRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = PoolRemoveRequestValidationError{}

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

// Validate checks the field values on PoolInfo 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 *PoolInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PoolInfo 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 PoolInfoMultiError, or nil
// if none found.
func (m *PoolInfo) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for PoolName

	// no validation rules for Total

	// no validation rules for Free

	// no validation rules for Reclaimable

	// no validation rules for NumberTapes

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m PoolInfoMultiError) 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 PoolInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = PoolInfoValidationError{}

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

// Validate checks the field values on PoolsInfo 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 *PoolsInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PoolsInfo 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 PoolsInfoMultiError, or nil
// if none found.
func (m *PoolsInfo) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, PoolsInfoValidationError{
						field:  fmt.Sprintf("Pools[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, PoolsInfoValidationError{
						field:  fmt.Sprintf("Pools[%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 PoolsInfoValidationError{
					field:  fmt.Sprintf("Pools[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m PoolsInfoMultiError) 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 PoolsInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = PoolsInfoValidationError{}

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

// Validate checks the field values on DriveInfo 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 *DriveInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DriveInfo 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 DriveInfoMultiError, or nil
// if none found.
func (m *DriveInfo) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Id

	// no validation rules for DeviceName

	// no validation rules for Slot

	// no validation rules for Status

	// no validation rules for Busy

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m DriveInfoMultiError) 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 DriveInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = DriveInfoValidationError{}

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

// Validate checks the field values on DrivesInfo 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 *DrivesInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on DrivesInfo 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 DrivesInfoMultiError, or
// nil if none found.
func (m *DrivesInfo) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, DrivesInfoValidationError{
						field:  fmt.Sprintf("Drives[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, DrivesInfoValidationError{
						field:  fmt.Sprintf("Drives[%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 DrivesInfoValidationError{
					field:  fmt.Sprintf("Drives[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m DrivesInfoMultiError) 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 DrivesInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = DrivesInfoValidationError{}

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

// Validate checks the field values on TapeInfo 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 *TapeInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on TapeInfo 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 TapeInfoMultiError, or nil
// if none found.
func (m *TapeInfo) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Id

	// no validation rules for Slot

	// no validation rules for TotalCapacity

	// no validation rules for RemainCapacity

	// no validation rules for Reclaimable

	// no validation rules for Status

	// no validation rules for Inprogress

	// no validation rules for Pool

	// no validation rules for State

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m TapeInfoMultiError) 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 TapeInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = TapeInfoValidationError{}

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

// Validate checks the field values on MediumInfo 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 *MediumInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MediumInfo 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 MediumInfoMultiError, or
// nil if none found.
func (m *MediumInfo) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, MediumInfoValidationError{
						field:  fmt.Sprintf("Tapes[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, MediumInfoValidationError{
						field:  fmt.Sprintf("Tapes[%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 MediumInfoValidationError{
					field:  fmt.Sprintf("Tapes[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m MediumInfoMultiError) 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 MediumInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = MediumInfoValidationError{}

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

// Validate checks the field values on ReplyMessage 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 *ReplyMessage) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on ReplyMessage 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 ReplyMessageMultiError, or
// nil if none found.
func (m *ReplyMessage) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for ErrorCode

	// no validation rules for ErrorMsg

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m ReplyMessageMultiError) 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 ReplyMessageMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = ReplyMessageValidationError{}

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

// Validate checks the field values on MigrateRequest 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 *MigrateRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MigrateRequest 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 MigrateRequestMultiError,
// or nil if none found.
func (m *MigrateRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

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

	// no validation rules for Premigrate

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m MigrateRequestMultiError) 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 MigrateRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = MigrateRequestValidationError{}

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

// Validate checks the field values on RecallRequest 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 *RecallRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on RecallRequest 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 RecallRequestMultiError, or
// nil if none found.
func (m *RecallRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Resident

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

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m RecallRequestMultiError) 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 RecallRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = RecallRequestValidationError{}

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

// Validate checks the field values on MigrationStatus 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 *MigrationStatus) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on MigrationStatus 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
// MigrationStatusMultiError, or nil if none found.
func (m *MigrationStatus) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Success

	// no validation rules for RequestNumber

	// no validation rules for Pid

	// no validation rules for Resident

	// no validation rules for Transferred

	// no validation rules for Premigrated

	// no validation rules for Migrated

	// no validation rules for Failed

	// no validation rules for Done

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m MigrationStatusMultiError) 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 MigrationStatusMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = MigrationStatusValidationError{}

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

// Validate checks the field values on AsyncStatusRequest 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 *AsyncStatusRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on AsyncStatusRequest 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
// AsyncStatusRequestMultiError, or nil if none found.
func (m *AsyncStatusRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for RequestNumber

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

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m AsyncStatusRequestMultiError) 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 AsyncStatusRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = AsyncStatusRequestValidationError{}

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

// Validate checks the field values on FileInfo 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 *FileInfo) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on FileInfo 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 FileInfoMultiError, or nil
// if none found.
func (m *FileInfo) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for MigrationState

	// no validation rules for FileName

	// no validation rules for Size

	// no validation rules for Blocks

	// no validation rules for FilesystemUidHigh

	// no validation rules for FilesystemUidLow

	// no validation rules for InodeGeneration

	// no validation rules for InodeNumber

	// no validation rules for TapeId

	// no validation rules for StartBlock

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m FileInfoMultiError) 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 FileInfoMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = FileInfoValidationError{}

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

// Validate checks the field values on FileInfoRequest 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 *FileInfoRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on FileInfoRequest 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
// FileInfoRequestMultiError, or nil if none found.
func (m *FileInfoRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for FileName

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

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m FileInfoRequestMultiError) 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 FileInfoRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = FileInfoRequestValidationError{}

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

// Validate checks the field values on Condition 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 *Condition) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on Condition 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 ConditionMultiError, or nil
// if none found.
func (m *Condition) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Type

	// no validation rules for Field

	// no validation rules for Op

	// no validation rules for GroupOp

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, ConditionValidationError{
						field:  fmt.Sprintf("Conditions[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, ConditionValidationError{
						field:  fmt.Sprintf("Conditions[%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 ConditionValidationError{
					field:  fmt.Sprintf("Conditions[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m ConditionMultiError) 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 ConditionMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = ConditionValidationError{}

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

// Validate checks the field values on Sort 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 *Sort) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on Sort 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 SortMultiError, or nil if none found.
func (m *Sort) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Field

	// no validation rules for Desc

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m SortMultiError) 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 SortMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = SortValidationError{}

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

// Validate checks the field values on SearchRequest 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 *SearchRequest) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SearchRequest 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 SearchRequestMultiError, or
// nil if none found.
func (m *SearchRequest) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for From

	// no validation rules for Size

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

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, SearchRequestValidationError{
						field:  fmt.Sprintf("Sort[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, SearchRequestValidationError{
						field:  fmt.Sprintf("Sort[%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 SearchRequestValidationError{
					field:  fmt.Sprintf("Sort[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m SearchRequestMultiError) 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 SearchRequestMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = SearchRequestValidationError{}

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

// Validate checks the field values on SearchResponse 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 *SearchResponse) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on SearchResponse 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 SearchResponseMultiError,
// or nil if none found.
func (m *SearchResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Total

	// no validation rules for Relation

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

		if all {
			switch v := interface{}(item).(type) {
			case interface{ ValidateAll() error }:
				if err := v.ValidateAll(); err != nil {
					errors = append(errors, SearchResponseValidationError{
						field:  fmt.Sprintf("Items[%v]", idx),
						reason: "embedded message failed validation",
						cause:  err,
					})
				}
			case interface{ Validate() error }:
				if err := v.Validate(); err != nil {
					errors = append(errors, SearchResponseValidationError{
						field:  fmt.Sprintf("Items[%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 SearchResponseValidationError{
					field:  fmt.Sprintf("Items[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m SearchResponseMultiError) 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 SearchResponseMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = SearchResponseValidationError{}

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

// Validate checks the field values on PrepareFileListResponse 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 *PrepareFileListResponse) Validate() error {
	return m.validate(false)
}

// ValidateAll checks the field values on PrepareFileListResponse 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
// PrepareFileListResponseMultiError, or nil if none found.
func (m *PrepareFileListResponse) ValidateAll() error {
	return m.validate(true)
}

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

	var errors []error

	// no validation rules for Id

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

	return nil
}

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

// Error returns a concatenation of all the error messages it wraps.
func (m PrepareFileListResponseMultiError) 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 PrepareFileListResponseMultiError) AllErrors() []error { return m }

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

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

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

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

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

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

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

var _ error = PrepareFileListResponseValidationError{}

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