volume.pb.validate.go

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

package apiv1

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
)

// define the regex for a UUID once up-front
var _volume_uuidPattern = regexp.MustCompile("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")

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

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

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

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Name

	// no validation rules for Project

	// no validation rules for Partition

	// no validation rules for StorageClass

	// no validation rules for Size

	// no validation rules for Usage

	// no validation rules for State

	// no validation rules for SourceSnapshotUuid

	// no validation rules for SourceSnapshotName

	// no validation rules for VolumeHandle

	// no validation rules for RebuildProgress

	// no validation rules for PrimaryNodeUuid

	// no validation rules for QosPolicyUuid

	// no validation rules for QosPolicyName

	// no validation rules for ReplicaCount

	// no validation rules for ProtectionState

	// no validation rules for LogicalUsedStorage

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = VolumeValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for LogicalUsedStorage

	// no validation rules for PhysicalUsedStorage

	// no validation rules for CompressionRatio

	// no validation rules for TotalCompressionRatio

	// no validation rules for PhysicalCapacity

	// no validation rules for PhysicalOwnedCapacity

	// no validation rules for PhysicalOwnedMemory

	// no validation rules for PhysicalMemory

	// no validation rules for UserWritten

	// no validation rules for UnrecoverableDataIntegrityErrors

	// no validation rules for RecoverableDataIntegrityErrors

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = VolumeStatisticsValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for Uuid

	// no validation rules for Name

	// no validation rules for Description

	// no validation rules for Project

	// no validation rules for Partition

	// no validation rules for StorageClass

	// no validation rules for Size

	// no validation rules for Usage

	// no validation rules for State

	// no validation rules for SourceVolumeUuid

	// no validation rules for SourceVolumeName

	// no validation rules for ReplicaCount

	// no validation rules for PrimaryNodeUuid

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = SnapshotValidationError{}

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

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

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

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

	var errors []error

	// no validation rules for PhysicalCapacity

	// no validation rules for PhysicalOwnedCapacity

	// no validation rules for PhysicalOwnedMemory

	// no validation rules for PhysicalMemory

	// no validation rules for UserWritten

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = SnapshotStatisticsValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = VolumeServiceGetRequestValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := VolumeServiceGetRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *VolumeServiceGetRequest) _validateUuid(uuid string) error {
	if matched := _volume_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = VolumeServiceGetRequestValidationError{}

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

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

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

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

	var errors []error

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := VolumeServiceListRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.Uuid != nil {

		if err := m._validateUuid(m.GetUuid()); err != nil {
			err = VolumeServiceListRequestValidationError{
				field:  "Uuid",
				reason: "value must be a valid UUID",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Partition != nil {
		// no validation rules for Partition
	}

	if m.Name != nil {
		// no validation rules for Name
	}

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

	return nil
}

func (m *VolumeServiceListRequest) _validateUuid(uuid string) error {
	if matched := _volume_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = VolumeServiceListRequestValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = VolumeServiceDeleteRequestValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := VolumeServiceDeleteRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *VolumeServiceDeleteRequest) _validateUuid(uuid string) error {
	if matched := _volume_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = VolumeServiceDeleteRequestValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = SnapshotServiceGetRequestValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := SnapshotServiceGetRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *SnapshotServiceGetRequest) _validateUuid(uuid string) error {
	if matched := _volume_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = SnapshotServiceGetRequestValidationError{}

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

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

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

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

	var errors []error

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := SnapshotServiceListRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if m.Uuid != nil {

		if err := m._validateUuid(m.GetUuid()); err != nil {
			err = SnapshotServiceListRequestValidationError{
				field:  "Uuid",
				reason: "value must be a valid UUID",
				cause:  err,
			}
			if !all {
				return err
			}
			errors = append(errors, err)
		}

	}

	if m.Partition != nil {
		// no validation rules for Partition
	}

	if m.Name != nil {
		// no validation rules for Name
	}

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

	return nil
}

func (m *SnapshotServiceListRequest) _validateUuid(uuid string) error {
	if matched := _volume_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = SnapshotServiceListRequestValidationError{}

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

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

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

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

	var errors []error

	if err := m._validateUuid(m.GetUuid()); err != nil {
		err = SnapshotServiceDeleteRequestValidationError{
			field:  "Uuid",
			reason: "value must be a valid UUID",
			cause:  err,
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

	if l := utf8.RuneCountInString(m.GetProject()); l < 2 || l > 128 {
		err := SnapshotServiceDeleteRequestValidationError{
			field:  "Project",
			reason: "value length must be between 2 and 128 runes, inclusive",
		}
		if !all {
			return err
		}
		errors = append(errors, err)
	}

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

	return nil
}

func (m *SnapshotServiceDeleteRequest) _validateUuid(uuid string) error {
	if matched := _volume_uuidPattern.MatchString(uuid); !matched {
		return errors.New("invalid uuid format")
	}

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = SnapshotServiceDeleteRequestValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = VolumeServiceGetResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = VolumeServiceListResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = VolumeServiceDeleteResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = SnapshotServiceGetResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = SnapshotServiceListResponseValidationError{}

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

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

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

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

	var errors []error

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

var _ error = SnapshotServiceDeleteResponseValidationError{}

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