github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/resources/v1/common/specs.pb.validate.go

// Code generated by protoc-gen-goten-validate
// File: edgelq/alerting/proto/v1/specs.proto
// DO NOT EDIT!!!

package rcommon

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

	gotenvalidate "github.com/cloudwan/goten-sdk/runtime/validate"
)

// proto imports
import (
	logging_log "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	monitoring_time_serie "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/time_serie"
	meta_resource "github.com/cloudwan/goten-sdk/meta-service/resources/v1/resource"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
)

var (
	_ = bytes.Equal
	_ = errors.New
	_ = fmt.Errorf
	_ = net.ParseIP
	_ = regexp.Match
	_ = strings.Split
	_ = time.Now
	_ = utf8.RuneCountInString
	_ = url.Parse
	_ = gotenvalidate.NewValidationError
)

// make sure we're using proto imports
var (
	_ = &logging_log.Log{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &monitoring_time_serie.Point{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &meta_resource.Resource{}
)

func (obj *LogCndSpec) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if obj.Query == nil {
		return gotenvalidate.NewValidationError("LogCndSpec", "query", obj.Query, "field is required", nil)
	}
	if subobj, ok := interface{}(obj.Query).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("LogCndSpec", "query", obj.Query, "nested object validation failed", err)
		}
	}
	if len(obj.GroupByLabels) < 1 {
		return gotenvalidate.NewValidationError("LogCndSpec", "groupByLabels", obj.GroupByLabels, "field must have at least 1 items", nil)
	}
	if len(obj.GroupByLabels) > 8 {
		return gotenvalidate.NewValidationError("LogCndSpec", "groupByLabels", obj.GroupByLabels, "field must have at most 8 items", nil)
	}
	if len(obj.GroupByLabels) > 1 {
		values := make(map[string]struct{})
		for _, v := range obj.GroupByLabels {
			if _, ok := values[v]; ok {
				return gotenvalidate.NewValidationError("LogCndSpec", "groupByLabels", obj.GroupByLabels, "field must contain unique items", nil)
			}
			values[v] = struct{}{}
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *LogCndSpec_Query) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if obj.Trigger == nil {
		return gotenvalidate.NewValidationError("Query", "trigger", obj.Trigger, "field is required", nil)
	}
	if subobj, ok := interface{}(obj.Trigger).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("Query", "trigger", obj.Trigger, "nested object validation failed", err)
		}
	}
	if obj.MinDuration != nil && obj.MinDuration.CheckValid() != nil {
		err := obj.MinDuration.CheckValid()
		return gotenvalidate.NewValidationError("Query", "minDuration", obj.MinDuration, "could not validate duration", err)
	} else {
		d := obj.MinDuration.AsDuration()

		if obj.MinDuration != nil {
			if !(d >= time.Duration(60000000000)) {
				return gotenvalidate.NewValidationError("Query", "minDuration", d, "field must be greater or equal to 1m0s", nil)
			}
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *LogCndSpec_Query_LabelTrigger) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.Key) > 64 {
		return gotenvalidate.NewValidationError("LabelTrigger", "key", obj.Key, "field must contain at most 64 characters", nil)
	}
	if obj.Key == "" {
		return gotenvalidate.NewValidationError("LabelTrigger", "key", obj.Key, "field is required", nil)
	}
	if len(obj.Values) < 1 {
		return gotenvalidate.NewValidationError("LabelTrigger", "values", obj.Values, "field must have at least 1 items", nil)
	}
	if len(obj.Values) > 25 {
		return gotenvalidate.NewValidationError("LabelTrigger", "values", obj.Values, "field must have at most 25 items", nil)
	}
	if len(obj.Values) > 1 {
		values := make(map[string]struct{})
		for _, v := range obj.Values {
			if _, ok := values[v]; ok {
				return gotenvalidate.NewValidationError("LabelTrigger", "values", obj.Values, "field must contain unique items", nil)
			}
			values[v] = struct{}{}
		}
	}
	for _, el := range obj.Values {

		if len(el) > 128 {
			return gotenvalidate.NewValidationError("LabelTrigger", "values", el, "field must contain at most 128 characters", nil)
		}
		if el == "" {
			return gotenvalidate.NewValidationError("LabelTrigger", "values", el, "field is required", nil)
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *LogCndSpec_Query_StringPayloadTrigger) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.ObjectSelector) < 0 {
		return gotenvalidate.NewValidationError("StringPayloadTrigger", "objectSelector", obj.ObjectSelector, "field must contain at least 0 characters", nil)
	}
	if len(obj.ObjectSelector) > 64 {
		return gotenvalidate.NewValidationError("StringPayloadTrigger", "objectSelector", obj.ObjectSelector, "field must contain at most 64 characters", nil)
	}
	if len(obj.Regex) > 64 {
		return gotenvalidate.NewValidationError("StringPayloadTrigger", "regex", obj.Regex, "field must contain at most 64 characters", nil)
	}
	if obj.Regex == "" {
		return gotenvalidate.NewValidationError("StringPayloadTrigger", "regex", obj.Regex, "field is required", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *LogCndSpec_Query_CompositeTrigger) GotenValidate() error {
	if obj == nil {
		return nil
	}
	for idx, elem := range obj.Triggers {
		if subobj, ok := interface{}(elem).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("CompositeTrigger", "triggers", obj.Triggers[idx], "nested object validation failed", err)
			}
		}
	}
	if _, ok := LogCndSpec_Query_CompositeTrigger_Operator_name[int32(obj.Operator)]; !ok {
		return gotenvalidate.NewValidationError("CompositeTrigger", "operator", obj.Operator, "field must be a defined enum value", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *LogCndSpec_Query_TriggerCnd) GotenValidate() error {
	if obj == nil {
		return nil
	}
	switch opt := obj.Type.(type) {
	case *LogCndSpec_Query_TriggerCnd_Label:
		if subobj, ok := interface{}(opt.Label).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("TriggerCnd", "label", opt.Label, "nested object validation failed", err)
			}
		}
	case *LogCndSpec_Query_TriggerCnd_StringContent:
		if subobj, ok := interface{}(opt.StringContent).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("TriggerCnd", "stringContent", opt.StringContent, "nested object validation failed", err)
			}
		}
	case *LogCndSpec_Query_TriggerCnd_Composite:
		if subobj, ok := interface{}(opt.Composite).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("TriggerCnd", "composite", opt.Composite, "nested object validation failed", err)
			}
		}
	default:
		_ = opt
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *TsCndSpec) GotenValidate() error {
	if obj == nil {
		return nil
	}
	for idx, elem := range obj.Queries {
		if subobj, ok := interface{}(elem).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("TsCndSpec", "queries", obj.Queries[idx], "nested object validation failed", err)
			}
		}
	}
	if len(obj.QueryGroupBy) < 0 {
		return gotenvalidate.NewValidationError("TsCndSpec", "queryGroupBy", obj.QueryGroupBy, "field must have at least 0 items", nil)
	}
	if len(obj.QueryGroupBy) > 8 {
		return gotenvalidate.NewValidationError("TsCndSpec", "queryGroupBy", obj.QueryGroupBy, "field must have at most 8 items", nil)
	}
	if len(obj.QueryGroupBy) > 1 {
		values := make(map[string]struct{})
		for _, v := range obj.QueryGroupBy {
			if _, ok := values[v]; ok {
				return gotenvalidate.NewValidationError("TsCndSpec", "queryGroupBy", obj.QueryGroupBy, "field must contain unique items", nil)
			}
			values[v] = struct{}{}
		}
	}
	if obj.ThresholdAlerting == nil {
		return gotenvalidate.NewValidationError("TsCndSpec", "thresholdAlerting", obj.ThresholdAlerting, "field is required", nil)
	}
	if subobj, ok := interface{}(obj.ThresholdAlerting).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("TsCndSpec", "thresholdAlerting", obj.ThresholdAlerting, "nested object validation failed", err)
		}
	}
	for idx, elem := range obj.AnomalyAlerting {
		if subobj, ok := interface{}(elem).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("TsCndSpec", "anomalyAlerting", obj.AnomalyAlerting[idx], "nested object validation failed", err)
			}
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *TsCndSpec_Query) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.Name) > 256 {
		return gotenvalidate.NewValidationError("Query", "name", obj.Name, "field must contain at most 256 characters", nil)
	}
	if obj.Name == "" {
		return gotenvalidate.NewValidationError("Query", "name", obj.Name, "field is required", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *TsCndSpec_ThresholdAlertingCfg) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if _, ok := TsCndSpec_ThresholdAlertingCfg_Operator_name[int32(obj.Operator)]; !ok {
		return gotenvalidate.NewValidationError("ThresholdAlertingCfg", "operator", obj.Operator, "field must be a defined enum value", nil)
	}
	if obj.AlignmentPeriod != nil && obj.AlignmentPeriod.CheckValid() != nil {
		err := obj.AlignmentPeriod.CheckValid()
		return gotenvalidate.NewValidationError("ThresholdAlertingCfg", "alignmentPeriod", obj.AlignmentPeriod, "could not validate duration", err)
	} else {
		d := obj.AlignmentPeriod.AsDuration()

		if obj.AlignmentPeriod != nil {
			if d != time.Duration(60000000000) && d != time.Duration(180000000000) && d != time.Duration(300000000000) && d != time.Duration(900000000000) && d != time.Duration(1800000000000) && d != time.Duration(3600000000000) && d != time.Duration(10800000000000) && d != time.Duration(21600000000000) && d != time.Duration(43200000000000) && d != time.Duration(86400000000000) {
				return gotenvalidate.NewValidationError("ThresholdAlertingCfg", "alignmentPeriod", d, "field must be equal to exactly one of the following values: 1m0s, 3m0s, 5m0s, 15m0s, 30m0s, 1h0m0s, 3h0m0s, 6h0m0s, 12h0m0s, 24h0m0s", nil)
			}
		}
	}
	if obj.RaiseAfter != nil && obj.RaiseAfter.CheckValid() != nil {
		err := obj.RaiseAfter.CheckValid()
		return gotenvalidate.NewValidationError("ThresholdAlertingCfg", "raiseAfter", obj.RaiseAfter, "could not validate duration", err)
	} else {
		d := obj.RaiseAfter.AsDuration()

		if obj.RaiseAfter != nil {
			if !(d > time.Duration(0)) {
				return gotenvalidate.NewValidationError("ThresholdAlertingCfg", "raiseAfter", d, "field must be greater than 0s", nil)
			}
		}
	}
	for idx, elem := range obj.PerQueryThresholds {
		if subobj, ok := interface{}(elem).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("ThresholdAlertingCfg", "perQueryThresholds", obj.PerQueryThresholds[idx], "nested object validation failed", err)
			}
		}
	}
	if obj.AdaptiveThresholdsDetectionPeriod != nil && obj.AdaptiveThresholdsDetectionPeriod.CheckValid() != nil {
		err := obj.AdaptiveThresholdsDetectionPeriod.CheckValid()
		return gotenvalidate.NewValidationError("ThresholdAlertingCfg", "adaptiveThresholdsDetectionPeriod", obj.AdaptiveThresholdsDetectionPeriod, "could not validate duration", err)
	} else {
		d := obj.AdaptiveThresholdsDetectionPeriod.AsDuration()

		if obj.AdaptiveThresholdsDetectionPeriod != nil {
			if !(d >= time.Duration(0)) {
				return gotenvalidate.NewValidationError("ThresholdAlertingCfg", "adaptiveThresholdsDetectionPeriod", d, "field must be greater or equal to 0s", nil)
			}
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *TsCndSpec_AnomalyAlertingCfg) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if obj.AnalysisWindow != nil && obj.AnalysisWindow.CheckValid() != nil {
		err := obj.AnalysisWindow.CheckValid()
		return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "analysisWindow", obj.AnalysisWindow, "could not validate duration", err)
	} else {
		d := obj.AnalysisWindow.AsDuration()

		if obj.AnalysisWindow != nil {
			if !(d >= time.Duration(1800000000000)) {
				return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "analysisWindow", d, "field must be greater or equal to 30m0s", nil)
			}
		}
	}
	if obj.StepInterval != nil && obj.StepInterval.CheckValid() != nil {
		err := obj.StepInterval.CheckValid()
		return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "stepInterval", obj.StepInterval, "could not validate duration", err)
	} else {
		d := obj.StepInterval.AsDuration()

		if obj.StepInterval != nil {
			if !(d >= time.Duration(300000000000)) {
				return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "stepInterval", d, "field must be greater or equal to 5m0s", nil)
			}
		}
	}
	if obj.TrainStepInterval != nil && obj.TrainStepInterval.CheckValid() != nil {
		err := obj.TrainStepInterval.CheckValid()
		return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "trainStepInterval", obj.TrainStepInterval, "could not validate duration", err)
	} else {
		d := obj.TrainStepInterval.AsDuration()

		if obj.TrainStepInterval != nil {
			if !(d >= time.Duration(300000000000)) {
				return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "trainStepInterval", d, "field must be greater or equal to 5m0s", nil)
			}
		}
	}
	if obj.AlignmentPeriod != nil && obj.AlignmentPeriod.CheckValid() != nil {
		err := obj.AlignmentPeriod.CheckValid()
		return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "alignmentPeriod", obj.AlignmentPeriod, "could not validate duration", err)
	} else {
		d := obj.AlignmentPeriod.AsDuration()

		if obj.AlignmentPeriod != nil {
			if d != time.Duration(60000000000) && d != time.Duration(180000000000) && d != time.Duration(300000000000) && d != time.Duration(900000000000) && d != time.Duration(1800000000000) && d != time.Duration(3600000000000) && d != time.Duration(10800000000000) && d != time.Duration(21600000000000) && d != time.Duration(43200000000000) && d != time.Duration(86400000000000) {
				return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "alignmentPeriod", d, "field must be equal to exactly one of the following values: 1m0s, 3m0s, 5m0s, 15m0s, 30m0s, 1h0m0s, 3h0m0s, 6h0m0s, 12h0m0s, 24h0m0s", nil)
			}
		}
	}
	if obj.RaiseAfter != nil && obj.RaiseAfter.CheckValid() != nil {
		err := obj.RaiseAfter.CheckValid()
		return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "raiseAfter", obj.RaiseAfter, "could not validate duration", err)
	} else {
		d := obj.RaiseAfter.AsDuration()

		if obj.RaiseAfter != nil {
			if !(d > time.Duration(0)) {
				return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "raiseAfter", d, "field must be greater than 0s", nil)
			}
		}
	}
	switch opt := obj.Model.(type) {
	case *TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder:
		if subobj, ok := interface{}(opt.LstmAutoencoder).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("AnomalyAlertingCfg", "lstmAutoencoder", opt.LstmAutoencoder, "nested object validation failed", err)
			}
		}
	default:
		_ = opt
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if subobj, ok := interface{}(obj.MaxUpper).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("AlertingThresholds", "maxUpper", obj.MaxUpper, "nested object validation failed", err)
		}
	}
	if subobj, ok := interface{}(obj.MaxLower).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("AlertingThresholds", "maxLower", obj.MaxLower, "nested object validation failed", err)
		}
	}
	if subobj, ok := interface{}(obj.MinUpper).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("AlertingThresholds", "minUpper", obj.MinUpper, "nested object validation failed", err)
		}
	}
	if subobj, ok := interface{}(obj.MinLower).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("AlertingThresholds", "minLower", obj.MinLower, "nested object validation failed", err)
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if !(obj.HiddenSize >= 8 && obj.HiddenSize <= 64) {
		return gotenvalidate.NewValidationError("LstmAutoEncoder", "hiddenSize", obj.HiddenSize, "field must be in range [8, 64]", nil)
	}
	if !(obj.MaxTrainingEpochs >= 32 && obj.MaxTrainingEpochs <= 1024) {
		return gotenvalidate.NewValidationError("LstmAutoEncoder", "maxTrainingEpochs", obj.MaxTrainingEpochs, "field must be in range [32, 1024]", nil)
	}
	if !(obj.MinTrainingEpochs >= 32 && obj.MinTrainingEpochs <= 1024) {
		return gotenvalidate.NewValidationError("LstmAutoEncoder", "minTrainingEpochs", obj.MinTrainingEpochs, "field must be in range [32, 1024]", nil)
	}
	if obj.TrainingPeriod != nil && obj.TrainingPeriod.CheckValid() != nil {
		err := obj.TrainingPeriod.CheckValid()
		return gotenvalidate.NewValidationError("LstmAutoEncoder", "trainingPeriod", obj.TrainingPeriod, "could not validate duration", err)
	} else {
		d := obj.TrainingPeriod.AsDuration()

		if obj.TrainingPeriod == nil {
			return gotenvalidate.NewValidationError("LstmAutoEncoder", "trainingPeriod", d, "field is required", nil)
		}

		if obj.TrainingPeriod != nil {
			if !(d >= time.Duration(86400000000000)) {
				return gotenvalidate.NewValidationError("LstmAutoEncoder", "trainingPeriod", d, "field must be greater or equal to 24h0m0s", nil)
			}
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if _, ok := PolicySpec_ProcessingLocation_name[int32(obj.ProcessingLocation)]; !ok {
		return gotenvalidate.NewValidationError("PolicySpec", "processingLocation", obj.ProcessingLocation, "field must be a defined enum value", nil)
	}
	if obj.ResourceIdentity == nil {
		return gotenvalidate.NewValidationError("PolicySpec", "resourceIdentity", obj.ResourceIdentity, "field is required", nil)
	}
	if subobj, ok := interface{}(obj.ResourceIdentity).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("PolicySpec", "resourceIdentity", obj.ResourceIdentity, "nested object validation failed", err)
		}
	}
	for idx, elem := range obj.SupportingQueries {
		if subobj, ok := interface{}(elem).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("PolicySpec", "supportingQueries", obj.SupportingQueries[idx], "nested object validation failed", err)
			}
		}
	}
	if subobj, ok := interface{}(obj.AiAgent).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("PolicySpec", "aiAgent", obj.AiAgent, "nested object validation failed", err)
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_ResourceIdentity) GotenValidate() error {
	if obj == nil {
		return nil
	}
	for idx, elem := range obj.Labels {
		if subobj, ok := interface{}(elem).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("ResourceIdentity", "labels", obj.Labels[idx], "nested object validation failed", err)
			}
		}
	}
	if len(obj.NamePatterns) < 1 {
		return gotenvalidate.NewValidationError("ResourceIdentity", "namePatterns", obj.NamePatterns, "field must have at least 1 items", nil)
	}
	if len(obj.NamePatterns) > 1 {
		return gotenvalidate.NewValidationError("ResourceIdentity", "namePatterns", obj.NamePatterns, "field must have at most 1 items", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_SupportingAlertQuery) GotenValidate() error {
	if obj == nil {
		return nil
	}
	switch opt := obj.Query.(type) {
	case *PolicySpec_SupportingAlertQuery_TsQuery_:
		if subobj, ok := interface{}(opt.TsQuery).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("SupportingAlertQuery", "tsQuery", opt.TsQuery, "nested object validation failed", err)
			}
		}
	case *PolicySpec_SupportingAlertQuery_LogQuery_:
		if subobj, ok := interface{}(opt.LogQuery).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("SupportingAlertQuery", "logQuery", opt.LogQuery, "nested object validation failed", err)
			}
		}
	case *PolicySpec_SupportingAlertQuery_RestGetQuery_:
		if subobj, ok := interface{}(opt.RestGetQuery).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("SupportingAlertQuery", "restGetQuery", opt.RestGetQuery, "nested object validation failed", err)
			}
		}
	case *PolicySpec_SupportingAlertQuery_RestListQuery_:
		if subobj, ok := interface{}(opt.RestListQuery).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("SupportingAlertQuery", "restListQuery", opt.RestListQuery, "nested object validation failed", err)
			}
		}
	default:
		_ = opt
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_AIAgentHandling) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if subobj, ok := interface{}(obj.EdgeConnectivity).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("AIAgentHandling", "edgeConnectivity", obj.EdgeConnectivity, "nested object validation failed", err)
		}
	}
	for idx, elem := range obj.RemediationOptions {
		if subobj, ok := interface{}(elem).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("AIAgentHandling", "remediationOptions", obj.RemediationOptions[idx], "nested object validation failed", err)
			}
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_ResourceIdentity_LabelInfo) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.Key) > 64 {
		return gotenvalidate.NewValidationError("LabelInfo", "key", obj.Key, "field must contain at most 64 characters", nil)
	}
	if obj.Key == "" {
		return gotenvalidate.NewValidationError("LabelInfo", "key", obj.Key, "field is required", nil)
	}
	if len(obj.Contexts) < 1 {
		return gotenvalidate.NewValidationError("LabelInfo", "contexts", obj.Contexts, "field must have at least 1 items", nil)
	}
	if len(obj.Contexts) > 1 {
		values := make(map[PolicySpec_ResourceIdentity_LabelInfo_UsageContext]struct{})
		for _, v := range obj.Contexts {
			if _, ok := values[v]; ok {
				return gotenvalidate.NewValidationError("LabelInfo", "contexts", obj.Contexts, "field must contain unique items", nil)
			}
			values[v] = struct{}{}
		}
	}
	for _, el := range obj.Contexts {

		if _, ok := PolicySpec_ResourceIdentity_LabelInfo_UsageContext_name[int32(el)]; !ok {
			return gotenvalidate.NewValidationError("LabelInfo", "contexts", el, "field must be a defined enum value", nil)
		}
	}
	if len(obj.MappedNameSegment) > 128 {
		return gotenvalidate.NewValidationError("LabelInfo", "mappedNameSegment", obj.MappedNameSegment, "field must contain at most 128 characters", nil)
	}
	if obj.MappedNameSegment == "" {
		return gotenvalidate.NewValidationError("LabelInfo", "mappedNameSegment", obj.MappedNameSegment, "field is required", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_SupportingAlertQuery_TsQuery) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.Description) > 256 {
		return gotenvalidate.NewValidationError("TsQuery", "description", obj.Description, "field must contain at most 256 characters", nil)
	}
	if obj.Description == "" {
		return gotenvalidate.NewValidationError("TsQuery", "description", obj.Description, "field is required", nil)
	}
	if len(obj.FilterTemplate) > 256 {
		return gotenvalidate.NewValidationError("TsQuery", "filterTemplate", obj.FilterTemplate, "field must contain at most 256 characters", nil)
	}
	if obj.FilterTemplate == "" {
		return gotenvalidate.NewValidationError("TsQuery", "filterTemplate", obj.FilterTemplate, "field is required", nil)
	}
	if obj.Aggregation == nil {
		return gotenvalidate.NewValidationError("TsQuery", "aggregation", obj.Aggregation, "field is required", nil)
	}
	if subobj, ok := interface{}(obj.Aggregation).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("TsQuery", "aggregation", obj.Aggregation, "nested object validation failed", err)
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_SupportingAlertQuery_LogQuery) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.Description) > 256 {
		return gotenvalidate.NewValidationError("LogQuery", "description", obj.Description, "field must contain at most 256 characters", nil)
	}
	if obj.Description == "" {
		return gotenvalidate.NewValidationError("LogQuery", "description", obj.Description, "field is required", nil)
	}
	if len(obj.FilterTemplate) > 256 {
		return gotenvalidate.NewValidationError("LogQuery", "filterTemplate", obj.FilterTemplate, "field must contain at most 256 characters", nil)
	}
	if obj.FilterTemplate == "" {
		return gotenvalidate.NewValidationError("LogQuery", "filterTemplate", obj.FilterTemplate, "field is required", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_SupportingAlertQuery_RestGetQuery) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.Description) > 256 {
		return gotenvalidate.NewValidationError("RestGetQuery", "description", obj.Description, "field must contain at most 256 characters", nil)
	}
	if obj.Description == "" {
		return gotenvalidate.NewValidationError("RestGetQuery", "description", obj.Description, "field is required", nil)
	}
	if uri, err := url.Parse(string(obj.Endpoint)); err != nil {
		return gotenvalidate.NewValidationError("RestGetQuery", "endpoint", obj.Endpoint, "field must contain a valid URI", nil)
	} else if !uri.IsAbs() {
		return gotenvalidate.NewValidationError("RestGetQuery", "endpoint", obj.Endpoint, "field must contain an absolute URI", nil)
	}
	if obj.Endpoint == "" {
		return gotenvalidate.NewValidationError("RestGetQuery", "endpoint", obj.Endpoint, "field is required", nil)
	}
	if len(obj.PathTemplate) > 256 {
		return gotenvalidate.NewValidationError("RestGetQuery", "pathTemplate", obj.PathTemplate, "field must contain at most 256 characters", nil)
	}
	if obj.PathTemplate == "" {
		return gotenvalidate.NewValidationError("RestGetQuery", "pathTemplate", obj.PathTemplate, "field is required", nil)
	}
	if len(obj.View) > 32 {
		return gotenvalidate.NewValidationError("RestGetQuery", "view", obj.View, "field must contain at most 32 characters", nil)
	}
	if len(obj.FieldMask) > 512 {
		return gotenvalidate.NewValidationError("RestGetQuery", "fieldMask", obj.FieldMask, "field must contain at most 512 characters", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_SupportingAlertQuery_RestListQuery) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.Description) > 256 {
		return gotenvalidate.NewValidationError("RestListQuery", "description", obj.Description, "field must contain at most 256 characters", nil)
	}
	if obj.Description == "" {
		return gotenvalidate.NewValidationError("RestListQuery", "description", obj.Description, "field is required", nil)
	}
	if uri, err := url.Parse(string(obj.Endpoint)); err != nil {
		return gotenvalidate.NewValidationError("RestListQuery", "endpoint", obj.Endpoint, "field must contain a valid URI", nil)
	} else if !uri.IsAbs() {
		return gotenvalidate.NewValidationError("RestListQuery", "endpoint", obj.Endpoint, "field must contain an absolute URI", nil)
	}
	if obj.Endpoint == "" {
		return gotenvalidate.NewValidationError("RestListQuery", "endpoint", obj.Endpoint, "field is required", nil)
	}
	if len(obj.PathTemplate) > 256 {
		return gotenvalidate.NewValidationError("RestListQuery", "pathTemplate", obj.PathTemplate, "field must contain at most 256 characters", nil)
	}
	if obj.PathTemplate == "" {
		return gotenvalidate.NewValidationError("RestListQuery", "pathTemplate", obj.PathTemplate, "field is required", nil)
	}
	if len(obj.View) > 32 {
		return gotenvalidate.NewValidationError("RestListQuery", "view", obj.View, "field must contain at most 32 characters", nil)
	}
	if len(obj.FieldMask) > 512 {
		return gotenvalidate.NewValidationError("RestListQuery", "fieldMask", obj.FieldMask, "field must contain at most 512 characters", nil)
	}
	if len(obj.FilterTemplate) > 256 {
		return gotenvalidate.NewValidationError("RestListQuery", "filterTemplate", obj.FilterTemplate, "field must contain at most 256 characters", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_AIAgentHandling_EdgeConnectivity) GotenValidate() error {
	if obj == nil {
		return nil
	}
	switch opt := obj.Type.(type) {
	case *PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh:
		if subobj, ok := interface{}(opt.DeviceSsh).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("EdgeConnectivity", "deviceSsh", opt.DeviceSsh, "nested object validation failed", err)
			}
		}
	case *PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh:
		if subobj, ok := interface{}(opt.ProxiesSsh).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("EdgeConnectivity", "proxiesSsh", opt.ProxiesSsh, "nested object validation failed", err)
			}
		}
	case *PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh:
		if subobj, ok := interface{}(opt.PodSsh).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("EdgeConnectivity", "podSsh", opt.PodSsh, "nested object validation failed", err)
			}
		}
	default:
		_ = opt
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_AIAgentHandling_Remediation) GotenValidate() error {
	if obj == nil {
		return nil
	}
	switch opt := obj.Type.(type) {
	case *PolicySpec_AIAgentHandling_Remediation_FixInSsh:
		if subobj, ok := interface{}(opt.FixInSsh).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("Remediation", "fixInSsh", opt.FixInSsh, "nested object validation failed", err)
			}
		}
	case *PolicySpec_AIAgentHandling_Remediation_Reboot_:
		if subobj, ok := interface{}(opt.Reboot).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("Remediation", "reboot", opt.Reboot, "nested object validation failed", err)
			}
		}
	default:
		_ = opt
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.ClientName) > 64 {
		return gotenvalidate.NewValidationError("DeviceSSH", "clientName", obj.ClientName, "field must contain at most 64 characters", nil)
	}
	if obj.ClientName == "" {
		return gotenvalidate.NewValidationError("DeviceSSH", "clientName", obj.ClientName, "field is required", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.ServiceDomain) > 64 {
		return gotenvalidate.NewValidationError("ProxiesSSH", "serviceDomain", obj.ServiceDomain, "field must contain at most 64 characters", nil)
	}
	if obj.ServiceDomain == "" {
		return gotenvalidate.NewValidationError("ProxiesSSH", "serviceDomain", obj.ServiceDomain, "field is required", nil)
	}
	if len(obj.ProviderNameTmpl) > 256 {
		return gotenvalidate.NewValidationError("ProxiesSSH", "providerNameTmpl", obj.ProviderNameTmpl, "field must contain at most 256 characters", nil)
	}
	if obj.ProviderNameTmpl == "" {
		return gotenvalidate.NewValidationError("ProxiesSSH", "providerNameTmpl", obj.ProviderNameTmpl, "field is required", nil)
	}
	if len(obj.ClientName) > 64 {
		return gotenvalidate.NewValidationError("ProxiesSSH", "clientName", obj.ClientName, "field must contain at most 64 characters", nil)
	}
	if obj.ClientName == "" {
		return gotenvalidate.NewValidationError("ProxiesSSH", "clientName", obj.ClientName, "field is required", nil)
	}
	if len(obj.ServiceName) > 128 {
		return gotenvalidate.NewValidationError("ProxiesSSH", "serviceName", obj.ServiceName, "field must contain at most 128 characters", nil)
	}
	if obj.ServiceName == "" {
		return gotenvalidate.NewValidationError("ProxiesSSH", "serviceName", obj.ServiceName, "field is required", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if len(obj.ClientName) > 64 {
		return gotenvalidate.NewValidationError("PodSSH", "clientName", obj.ClientName, "field must contain at most 64 characters", nil)
	}
	if obj.ClientName == "" {
		return gotenvalidate.NewValidationError("PodSSH", "clientName", obj.ClientName, "field is required", nil)
	}
	if len(obj.Username) > 32 {
		return gotenvalidate.NewValidationError("PodSSH", "username", obj.Username, "field must contain at most 32 characters", nil)
	}
	if obj.Username == "" {
		return gotenvalidate.NewValidationError("PodSSH", "username", obj.Username, "field is required", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_AIAgentHandling_Remediation_FixInSSH) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *PolicySpec_AIAgentHandling_Remediation_Reboot) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *NotificationChannelSpec) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if _, ok := NotificationChannelSpec_Type_name[int32(obj.Type)]; !ok {
		return gotenvalidate.NewValidationError("NotificationChannelSpec", "type", obj.Type, "field must be a defined enum value", nil)
	}
	for _, el := range obj.EnabledKinds {

		if _, ok := NotificationChannelSpec_EventKind_name[int32(el)]; !ok {
			return gotenvalidate.NewValidationError("NotificationChannelSpec", "enabledKinds", el, "field must be a defined enum value", nil)
		}
	}
	if subobj, ok := interface{}(obj.Email).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("NotificationChannelSpec", "email", obj.Email, "nested object validation failed", err)
		}
	}
	if subobj, ok := interface{}(obj.Slack).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("NotificationChannelSpec", "slack", obj.Slack, "nested object validation failed", err)
		}
	}
	if subobj, ok := interface{}(obj.Webhook).(gotenvalidate.Validator); ok {
		if err := subobj.GotenValidate(); err != nil {
			return gotenvalidate.NewValidationError("NotificationChannelSpec", "webhook", obj.Webhook, "nested object validation failed", err)
		}
	}
	if !(obj.MaxAlertBodiesInMsg >= 0) {
		return gotenvalidate.NewValidationError("NotificationChannelSpec", "maxAlertBodiesInMsg", obj.MaxAlertBodiesInMsg, "field must be greater or equal to 0", nil)
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *NotificationChannelSpec_Email) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *NotificationChannelSpec_Slack) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *NotificationChannelSpec_PagerDuty) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *NotificationChannelSpec_Webhook) GotenValidate() error {
	if obj == nil {
		return nil
	}
	for idx, elem := range obj.Headers {
		if subobj, ok := interface{}(elem).(gotenvalidate.Validator); ok {
			if err := subobj.GotenValidate(); err != nil {
				return gotenvalidate.NewValidationError("Webhook", "headers", obj.Headers[idx], "nested object validation failed", err)
			}
		}
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *NotificationChannelSpec_Webhook_Header) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}
func (obj *AlertingThreshold) GotenValidate() error {
	if obj == nil {
		return nil
	}
	if cvobj, ok := interface{}(obj).(gotenvalidate.CustomValidator); ok {
		return cvobj.GotenCustomValidate()
	}
	return nil
}