gateway.pb.validate.go

// Code generated by protoc-gen-fieldmask. DO NOT EDIT.

package ttnpb

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

	"github.com/gogo/protobuf/types"
)

// 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)
	_ = types.DynamicAny{}
)

// define the regex for a UUID once up-front
var _gateway_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}$")

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

	if len(paths) == 0 {
		paths = GatewayBrandFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "id":
			// no validation rules for ID
		case "name":
			// no validation rules for Name
		case "url":
			// no validation rules for URL
		case "logos":

		default:
			return GatewayBrandValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayBrandValidationError{}

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

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

	if len(paths) == 0 {
		paths = GatewayModelFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "brand_id":

			if utf8.RuneCountInString(m.GetBrandID()) > 36 {
				return GatewayModelValidationError{
					field:  "brand_id",
					reason: "value length must be at most 36 runes",
				}
			}

			if !_GatewayModel_BrandID_Pattern.MatchString(m.GetBrandID()) {
				return GatewayModelValidationError{
					field:  "brand_id",
					reason: "value does not match regex pattern \"^[a-z0-9](?:[-]?[a-z0-9]){2,}$\"",
				}
			}

		case "id":

			if utf8.RuneCountInString(m.GetID()) > 36 {
				return GatewayModelValidationError{
					field:  "id",
					reason: "value length must be at most 36 runes",
				}
			}

			if !_GatewayModel_ID_Pattern.MatchString(m.GetID()) {
				return GatewayModelValidationError{
					field:  "id",
					reason: "value does not match regex pattern \"^[a-z0-9](?:[-]?[a-z0-9]){2,}$\"",
				}
			}

		case "name":
			// no validation rules for Name
		default:
			return GatewayModelValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayModelValidationError{}

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

var _GatewayModel_BrandID_Pattern = regexp.MustCompile("^[a-z0-9](?:[-]?[a-z0-9]){2,}$")

var _GatewayModel_ID_Pattern = regexp.MustCompile("^[a-z0-9](?:[-]?[a-z0-9]){2,}$")

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

	if len(paths) == 0 {
		paths = GatewayVersionIdentifiersFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "brand_id":

			if utf8.RuneCountInString(m.GetBrandID()) > 36 {
				return GatewayVersionIdentifiersValidationError{
					field:  "brand_id",
					reason: "value length must be at most 36 runes",
				}
			}

			if !_GatewayVersionIdentifiers_BrandID_Pattern.MatchString(m.GetBrandID()) {
				return GatewayVersionIdentifiersValidationError{
					field:  "brand_id",
					reason: "value does not match regex pattern \"^[a-z0-9](?:[-]?[a-z0-9]){2,}$\"",
				}
			}

		case "model_id":

			if utf8.RuneCountInString(m.GetModelID()) > 36 {
				return GatewayVersionIdentifiersValidationError{
					field:  "model_id",
					reason: "value length must be at most 36 runes",
				}
			}

			if !_GatewayVersionIdentifiers_ModelID_Pattern.MatchString(m.GetModelID()) {
				return GatewayVersionIdentifiersValidationError{
					field:  "model_id",
					reason: "value does not match regex pattern \"^[a-z0-9](?:[-]?[a-z0-9]){2,}$\"",
				}
			}

		case "hardware_version":

			if utf8.RuneCountInString(m.GetHardwareVersion()) > 32 {
				return GatewayVersionIdentifiersValidationError{
					field:  "hardware_version",
					reason: "value length must be at most 32 runes",
				}
			}

		case "firmware_version":

			if utf8.RuneCountInString(m.GetFirmwareVersion()) > 32 {
				return GatewayVersionIdentifiersValidationError{
					field:  "firmware_version",
					reason: "value length must be at most 32 runes",
				}
			}

		default:
			return GatewayVersionIdentifiersValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayVersionIdentifiersValidationError{}

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

var _GatewayVersionIdentifiers_BrandID_Pattern = regexp.MustCompile("^[a-z0-9](?:[-]?[a-z0-9]){2,}$")

var _GatewayVersionIdentifiers_ModelID_Pattern = regexp.MustCompile("^[a-z0-9](?:[-]?[a-z0-9]){2,}$")

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

	if len(paths) == 0 {
		paths = GatewayRadioFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "enable":
			// no validation rules for Enable
		case "chip_type":
			// no validation rules for ChipType
		case "frequency":
			// no validation rules for Frequency
		case "rssi_offset":
			// no validation rules for RSSIOffset
		case "tx_configuration":

			if v, ok := interface{}(m.GetTxConfiguration()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayRadioValidationError{
						field:  "tx_configuration",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return GatewayRadioValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayRadioValidationError{}

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

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

	if len(paths) == 0 {
		paths = GatewayVersionFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "ids":

			if v, ok := interface{}(&m.GatewayVersionIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayVersionValidationError{
						field:  "ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "photos":

		case "radios":

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

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

			}

		case "clock_source":
			// no validation rules for ClockSource
		default:
			return GatewayVersionValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayVersionValidationError{}

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

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

	if len(paths) == 0 {
		paths = GatewayClaimAuthenticationCodeFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "secret":

			if v, ok := interface{}(m.GetSecret()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayClaimAuthenticationCodeValidationError{
						field:  "secret",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "valid_from":

			if v, ok := interface{}(m.GetValidFrom()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayClaimAuthenticationCodeValidationError{
						field:  "valid_from",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "valid_to":

			if v, ok := interface{}(m.GetValidTo()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayClaimAuthenticationCodeValidationError{
						field:  "valid_to",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return GatewayClaimAuthenticationCodeValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayClaimAuthenticationCodeValidationError{}

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

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

	if len(paths) == 0 {
		paths = GatewayFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "ids":

			if v, ok := interface{}(&m.GatewayIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayValidationError{
						field:  "ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "created_at":

			if v, ok := interface{}(&m.CreatedAt).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayValidationError{
						field:  "created_at",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "updated_at":

			if v, ok := interface{}(&m.UpdatedAt).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayValidationError{
						field:  "updated_at",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "name":

			if utf8.RuneCountInString(m.GetName()) > 50 {
				return GatewayValidationError{
					field:  "name",
					reason: "value length must be at most 50 runes",
				}
			}

		case "description":

			if utf8.RuneCountInString(m.GetDescription()) > 2000 {
				return GatewayValidationError{
					field:  "description",
					reason: "value length must be at most 2000 runes",
				}
			}

		case "attributes":

			if len(m.GetAttributes()) > 10 {
				return GatewayValidationError{
					field:  "attributes",
					reason: "value must contain no more than 10 pair(s)",
				}
			}

			for key, val := range m.GetAttributes() {
				_ = val

				if utf8.RuneCountInString(key) > 36 {
					return GatewayValidationError{
						field:  fmt.Sprintf("attributes[%v]", key),
						reason: "value length must be at most 36 runes",
					}
				}

				if !_Gateway_Attributes_Pattern.MatchString(key) {
					return GatewayValidationError{
						field:  fmt.Sprintf("attributes[%v]", key),
						reason: "value does not match regex pattern \"^[a-z0-9](?:[-]?[a-z0-9]){2,}$\"",
					}
				}

				if utf8.RuneCountInString(val) > 200 {
					return GatewayValidationError{
						field:  fmt.Sprintf("attributes[%v]", key),
						reason: "value length must be at most 200 runes",
					}
				}

			}

		case "contact_info":

			if len(m.GetContactInfo()) > 10 {
				return GatewayValidationError{
					field:  "contact_info",
					reason: "value must contain no more than 10 item(s)",
				}
			}

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

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

			}

		case "version_ids":

			if v, ok := interface{}(&m.GatewayVersionIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayValidationError{
						field:  "version_ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "gateway_server_address":

			if !_Gateway_GatewayServerAddress_Pattern.MatchString(m.GetGatewayServerAddress()) {
				return GatewayValidationError{
					field:  "gateway_server_address",
					reason: "value does not match regex pattern \"^(?:(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\\\-]*[a-zA-Z0-9])\\\\.)*(?:[A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\\\-]*[A-Za-z0-9])(?::[0-9]{1,5})?$|^$\"",
				}
			}

		case "auto_update":
			// no validation rules for AutoUpdate
		case "update_channel":

			if utf8.RuneCountInString(m.GetUpdateChannel()) > 128 {
				return GatewayValidationError{
					field:  "update_channel",
					reason: "value length must be at most 128 runes",
				}
			}

		case "frequency_plan_id":

			if utf8.RuneCountInString(m.GetFrequencyPlanID()) > 64 {
				return GatewayValidationError{
					field:  "frequency_plan_id",
					reason: "value length must be at most 64 runes",
				}
			}

		case "frequency_plan_ids":

			if len(m.GetFrequencyPlanIDs()) > 8 {
				return GatewayValidationError{
					field:  "frequency_plan_ids",
					reason: "value must contain no more than 8 item(s)",
				}
			}

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

				if utf8.RuneCountInString(item) > 64 {
					return GatewayValidationError{
						field:  fmt.Sprintf("frequency_plan_ids[%v]", idx),
						reason: "value length must be at most 64 runes",
					}
				}

			}

		case "antennas":

			if len(m.Antennas) > 8 {
				return GatewayValidationError{
					field:  "antennas",
					reason: "value must contain no more than 8 item(s)",
				}
			}

			for idx, item := range m.Antennas {
				_, _ = idx, item

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

			}

		case "status_public":
			// no validation rules for StatusPublic
		case "location_public":
			// no validation rules for LocationPublic
		case "schedule_downlink_late":
			// no validation rules for ScheduleDownlinkLate
		case "enforce_duty_cycle":
			// no validation rules for EnforceDutyCycle
		case "downlink_path_constraint":

			if _, ok := DownlinkPathConstraint_name[int32(m.GetDownlinkPathConstraint())]; !ok {
				return GatewayValidationError{
					field:  "downlink_path_constraint",
					reason: "value must be one of the defined enum values",
				}
			}

		case "schedule_anytime_delay":

			if v, ok := interface{}(m.GetScheduleAnytimeDelay()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayValidationError{
						field:  "schedule_anytime_delay",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "update_location_from_status":
			// no validation rules for UpdateLocationFromStatus
		case "lbs_lns_secret":

			if v, ok := interface{}(m.GetLBSLNSSecret()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayValidationError{
						field:  "lbs_lns_secret",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "claim_authentication_code":

			if v, ok := interface{}(m.GetClaimAuthenticationCode()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayValidationError{
						field:  "claim_authentication_code",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "target_cups_uri":

			if uri, err := url.Parse(m.GetTargetCUPSURI()); err != nil {
				return GatewayValidationError{
					field:  "target_cups_uri",
					reason: "value must be a valid URI",
					cause:  err,
				}
			} else if !uri.IsAbs() {
				return GatewayValidationError{
					field:  "target_cups_uri",
					reason: "value must be absolute",
				}
			}

		case "target_cups_key":

			if v, ok := interface{}(m.GetTargetCUPSKey()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayValidationError{
						field:  "target_cups_key",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return GatewayValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayValidationError{}

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

var _Gateway_Attributes_Pattern = regexp.MustCompile("^[a-z0-9](?:[-]?[a-z0-9]){2,}$")

var _Gateway_GatewayServerAddress_Pattern = regexp.MustCompile("^(?:(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*(?:[A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])(?::[0-9]{1,5})?$|^$")

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

	if len(paths) == 0 {
		paths = GatewaysFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateways":

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

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

			}

		default:
			return GatewaysValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewaysValidationError{}

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

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

	if len(paths) == 0 {
		paths = GetGatewayRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway_ids":

			if v, ok := interface{}(&m.GatewayIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GetGatewayRequestValidationError{
						field:  "gateway_ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "field_mask":

			if v, ok := interface{}(&m.FieldMask).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GetGatewayRequestValidationError{
						field:  "field_mask",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return GetGatewayRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetGatewayRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = GetGatewayIdentifiersForEUIRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "eui":
			// no validation rules for EUI
		default:
			return GetGatewayIdentifiersForEUIRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetGatewayIdentifiersForEUIRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = ListGatewaysRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "collaborator":

			if v, ok := interface{}(m.GetCollaborator()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return ListGatewaysRequestValidationError{
						field:  "collaborator",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "field_mask":

			if v, ok := interface{}(&m.FieldMask).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return ListGatewaysRequestValidationError{
						field:  "field_mask",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "order":

			if _, ok := _ListGatewaysRequest_Order_InLookup[m.GetOrder()]; !ok {
				return ListGatewaysRequestValidationError{
					field:  "order",
					reason: "value must be in list [ gateway_id -gateway_id gateway_eui -gateway_eui name -name created_at -created_at]",
				}
			}

		case "limit":

			if m.GetLimit() > 1000 {
				return ListGatewaysRequestValidationError{
					field:  "limit",
					reason: "value must be less than or equal to 1000",
				}
			}

		case "page":
			// no validation rules for Page
		default:
			return ListGatewaysRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListGatewaysRequestValidationError{}

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

var _ListGatewaysRequest_Order_InLookup = map[string]struct{}{
	"":             {},
	"gateway_id":   {},
	"-gateway_id":  {},
	"gateway_eui":  {},
	"-gateway_eui": {},
	"name":         {},
	"-name":        {},
	"created_at":   {},
	"-created_at":  {},
}

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

	if len(paths) == 0 {
		paths = CreateGatewayRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway":

			if v, ok := interface{}(&m.Gateway).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return CreateGatewayRequestValidationError{
						field:  "gateway",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "collaborator":

			if v, ok := interface{}(&m.Collaborator).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return CreateGatewayRequestValidationError{
						field:  "collaborator",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return CreateGatewayRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CreateGatewayRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = UpdateGatewayRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway":

			if v, ok := interface{}(&m.Gateway).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return UpdateGatewayRequestValidationError{
						field:  "gateway",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "field_mask":

			if v, ok := interface{}(&m.FieldMask).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return UpdateGatewayRequestValidationError{
						field:  "field_mask",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return UpdateGatewayRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateGatewayRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = ListGatewayAPIKeysRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway_ids":

			if v, ok := interface{}(&m.GatewayIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return ListGatewayAPIKeysRequestValidationError{
						field:  "gateway_ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "limit":

			if m.GetLimit() > 1000 {
				return ListGatewayAPIKeysRequestValidationError{
					field:  "limit",
					reason: "value must be less than or equal to 1000",
				}
			}

		case "page":
			// no validation rules for Page
		default:
			return ListGatewayAPIKeysRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListGatewayAPIKeysRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = GetGatewayAPIKeyRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway_ids":

			if v, ok := interface{}(&m.GatewayIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GetGatewayAPIKeyRequestValidationError{
						field:  "gateway_ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "key_id":
			// no validation rules for KeyID
		default:
			return GetGatewayAPIKeyRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetGatewayAPIKeyRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = CreateGatewayAPIKeyRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway_ids":

			if v, ok := interface{}(&m.GatewayIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return CreateGatewayAPIKeyRequestValidationError{
						field:  "gateway_ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "name":

			if utf8.RuneCountInString(m.GetName()) > 50 {
				return CreateGatewayAPIKeyRequestValidationError{
					field:  "name",
					reason: "value length must be at most 50 runes",
				}
			}

		case "rights":

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

				if _, ok := Right_name[int32(item)]; !ok {
					return CreateGatewayAPIKeyRequestValidationError{
						field:  fmt.Sprintf("rights[%v]", idx),
						reason: "value must be one of the defined enum values",
					}
				}

			}

		default:
			return CreateGatewayAPIKeyRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = CreateGatewayAPIKeyRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = UpdateGatewayAPIKeyRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway_ids":

			if v, ok := interface{}(&m.GatewayIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return UpdateGatewayAPIKeyRequestValidationError{
						field:  "gateway_ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "api_key":

			if v, ok := interface{}(&m.APIKey).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return UpdateGatewayAPIKeyRequestValidationError{
						field:  "api_key",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return UpdateGatewayAPIKeyRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = UpdateGatewayAPIKeyRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = ListGatewayCollaboratorsRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway_ids":

			if v, ok := interface{}(&m.GatewayIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return ListGatewayCollaboratorsRequestValidationError{
						field:  "gateway_ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "limit":

			if m.GetLimit() > 1000 {
				return ListGatewayCollaboratorsRequestValidationError{
					field:  "limit",
					reason: "value must be less than or equal to 1000",
				}
			}

		case "page":
			// no validation rules for Page
		default:
			return ListGatewayCollaboratorsRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = ListGatewayCollaboratorsRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = GetGatewayCollaboratorRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway_ids":

			if v, ok := interface{}(&m.GatewayIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GetGatewayCollaboratorRequestValidationError{
						field:  "gateway_ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "collaborator":

			if v, ok := interface{}(&m.OrganizationOrUserIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GetGatewayCollaboratorRequestValidationError{
						field:  "collaborator",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return GetGatewayCollaboratorRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GetGatewayCollaboratorRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = SetGatewayCollaboratorRequestFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gateway_ids":

			if v, ok := interface{}(&m.GatewayIdentifiers).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return SetGatewayCollaboratorRequestValidationError{
						field:  "gateway_ids",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "collaborator":

			if v, ok := interface{}(&m.Collaborator).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return SetGatewayCollaboratorRequestValidationError{
						field:  "collaborator",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return SetGatewayCollaboratorRequestValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = SetGatewayCollaboratorRequestValidationError{}

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

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

	if len(paths) == 0 {
		paths = GatewayAntennaFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "gain":
			// no validation rules for Gain
		case "location":

			if v, ok := interface{}(&m.Location).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayAntennaValidationError{
						field:  "location",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "attributes":

			if len(m.GetAttributes()) > 10 {
				return GatewayAntennaValidationError{
					field:  "attributes",
					reason: "value must contain no more than 10 pair(s)",
				}
			}

			for key, val := range m.GetAttributes() {
				_ = val

				if utf8.RuneCountInString(key) > 36 {
					return GatewayAntennaValidationError{
						field:  fmt.Sprintf("attributes[%v]", key),
						reason: "value length must be at most 36 runes",
					}
				}

				if !_GatewayAntenna_Attributes_Pattern.MatchString(key) {
					return GatewayAntennaValidationError{
						field:  fmt.Sprintf("attributes[%v]", key),
						reason: "value does not match regex pattern \"^[a-z0-9](?:[-]?[a-z0-9]){2,}$\"",
					}
				}

				if utf8.RuneCountInString(val) > 200 {
					return GatewayAntennaValidationError{
						field:  fmt.Sprintf("attributes[%v]", key),
						reason: "value length must be at most 200 runes",
					}
				}

			}

		default:
			return GatewayAntennaValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayAntennaValidationError{}

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

var _GatewayAntenna_Attributes_Pattern = regexp.MustCompile("^[a-z0-9](?:[-]?[a-z0-9]){2,}$")

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

	if len(paths) == 0 {
		paths = GatewayStatusFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "time":

		case "boot_time":

			if v, ok := interface{}(&m.BootTime).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayStatusValidationError{
						field:  "boot_time",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "versions":

			if len(m.GetVersions()) > 10 {
				return GatewayStatusValidationError{
					field:  "versions",
					reason: "value must contain no more than 10 pair(s)",
				}
			}

			for key, val := range m.GetVersions() {
				_ = val

				if utf8.RuneCountInString(key) > 36 {
					return GatewayStatusValidationError{
						field:  fmt.Sprintf("versions[%v]", key),
						reason: "value length must be at most 36 runes",
					}
				}

				if !_GatewayStatus_Versions_Pattern.MatchString(key) {
					return GatewayStatusValidationError{
						field:  fmt.Sprintf("versions[%v]", key),
						reason: "value does not match regex pattern \"^[a-z0-9](?:[_-]?[a-z0-9]){2,}$\"",
					}
				}

				if utf8.RuneCountInString(val) > 32 {
					return GatewayStatusValidationError{
						field:  fmt.Sprintf("versions[%v]", key),
						reason: "value length must be at most 32 runes",
					}
				}

			}

		case "antenna_locations":

			if len(m.GetAntennaLocations()) > 8 {
				return GatewayStatusValidationError{
					field:  "antenna_locations",
					reason: "value must contain no more than 8 item(s)",
				}
			}

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

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

			}

		case "ip":

			if len(m.GetIP()) > 10 {
				return GatewayStatusValidationError{
					field:  "ip",
					reason: "value must contain no more than 10 item(s)",
				}
			}

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

				if ip := net.ParseIP(item); ip == nil {
					return GatewayStatusValidationError{
						field:  fmt.Sprintf("ip[%v]", idx),
						reason: "value must be a valid IP address",
					}
				}

			}

		case "metrics":

			if len(m.GetMetrics()) > 10 {
				return GatewayStatusValidationError{
					field:  "metrics",
					reason: "value must contain no more than 10 pair(s)",
				}
			}

			for key, val := range m.GetMetrics() {
				_ = val

				if utf8.RuneCountInString(key) > 36 {
					return GatewayStatusValidationError{
						field:  fmt.Sprintf("metrics[%v]", key),
						reason: "value length must be at most 36 runes",
					}
				}

				if !_GatewayStatus_Metrics_Pattern.MatchString(key) {
					return GatewayStatusValidationError{
						field:  fmt.Sprintf("metrics[%v]", key),
						reason: "value does not match regex pattern \"^[a-z0-9](?:[_-]?[a-z0-9]){2,}$\"",
					}
				}

				// no validation rules for Metrics[key]
			}

		case "advanced":

			if v, ok := interface{}(m.GetAdvanced()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayStatusValidationError{
						field:  "advanced",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		default:
			return GatewayStatusValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayStatusValidationError{}

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

var _GatewayStatus_Versions_Pattern = regexp.MustCompile("^[a-z0-9](?:[_-]?[a-z0-9]){2,}$")

var _GatewayStatus_Metrics_Pattern = regexp.MustCompile("^[a-z0-9](?:[_-]?[a-z0-9]){2,}$")

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

	if len(paths) == 0 {
		paths = GatewayConnectionStatsFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "connected_at":

			if v, ok := interface{}(m.GetConnectedAt()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayConnectionStatsValidationError{
						field:  "connected_at",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "protocol":
			// no validation rules for Protocol
		case "last_status_received_at":

			if v, ok := interface{}(m.GetLastStatusReceivedAt()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayConnectionStatsValidationError{
						field:  "last_status_received_at",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "last_status":

			if v, ok := interface{}(m.GetLastStatus()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayConnectionStatsValidationError{
						field:  "last_status",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "last_uplink_received_at":

			if v, ok := interface{}(m.GetLastUplinkReceivedAt()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayConnectionStatsValidationError{
						field:  "last_uplink_received_at",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "uplink_count":
			// no validation rules for UplinkCount
		case "last_downlink_received_at":

			if v, ok := interface{}(m.GetLastDownlinkReceivedAt()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayConnectionStatsValidationError{
						field:  "last_downlink_received_at",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "downlink_count":
			// no validation rules for DownlinkCount
		case "round_trip_times":

			if v, ok := interface{}(m.GetRoundTripTimes()).(interface{ ValidateFields(...string) error }); ok {
				if err := v.ValidateFields(subs...); err != nil {
					return GatewayConnectionStatsValidationError{
						field:  "round_trip_times",
						reason: "embedded message failed validation",
						cause:  err,
					}
				}
			}

		case "sub_bands":

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

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

			}

		default:
			return GatewayConnectionStatsValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayConnectionStatsValidationError{}

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

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

	if len(paths) == 0 {
		paths = GatewayRadio_TxConfigurationFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "min_frequency":
			// no validation rules for MinFrequency
		case "max_frequency":
			// no validation rules for MaxFrequency
		case "notch_frequency":
			// no validation rules for NotchFrequency
		default:
			return GatewayRadio_TxConfigurationValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayRadio_TxConfigurationValidationError{}

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

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

	if len(paths) == 0 {
		paths = GatewayConnectionStats_RoundTripTimesFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "min":

		case "max":

		case "median":

		case "count":
			// no validation rules for Count
		default:
			return GatewayConnectionStats_RoundTripTimesValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayConnectionStats_RoundTripTimesValidationError{}

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

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

	if len(paths) == 0 {
		paths = GatewayConnectionStats_SubBandFieldPathsNested
	}

	for name, subs := range _processPaths(append(paths[:0:0], paths...)) {
		_ = subs
		switch name {
		case "min_frequency":
			// no validation rules for MinFrequency
		case "max_frequency":
			// no validation rules for MaxFrequency
		case "downlink_utilization_limit":
			// no validation rules for DownlinkUtilizationLimit
		case "downlink_utilization":
			// no validation rules for DownlinkUtilization
		default:
			return GatewayConnectionStats_SubBandValidationError{
				field:  name,
				reason: "invalid field path",
			}
		}
	}
	return nil
}

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

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

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

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

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

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

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

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

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

var _ error = GatewayConnectionStats_SubBandValidationError{}

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