alerting_policy.pb.fieldpathbuilder.go

// Code generated by protoc-gen-goten-object
// File: edgelq/monitoring/proto/v4/alerting_policy.proto
// DO NOT EDIT!!!

package alerting_policy

// proto imports
import (
	notification_channel "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/notification_channel"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/project"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// make sure we're using proto imports
var (
	_ = &notification_channel.NotificationChannel{}
	_ = &project.Project{}
	_ = &timestamppb.Timestamp{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type AlertingPolicyFieldPathBuilder struct{}

func NewAlertingPolicyFieldPathBuilder() AlertingPolicyFieldPathBuilder {
	return AlertingPolicyFieldPathBuilder{}
}
func (AlertingPolicyFieldPathBuilder) Name() AlertingPolicyPathSelectorName {
	return AlertingPolicyPathSelectorName{}
}
func (AlertingPolicyFieldPathBuilder) Metadata() AlertingPolicyPathSelectorMetadata {
	return AlertingPolicyPathSelectorMetadata{}
}
func (AlertingPolicyFieldPathBuilder) DisplayName() AlertingPolicyPathSelectorDisplayName {
	return AlertingPolicyPathSelectorDisplayName{}
}
func (AlertingPolicyFieldPathBuilder) Description() AlertingPolicyPathSelectorDescription {
	return AlertingPolicyPathSelectorDescription{}
}
func (AlertingPolicyFieldPathBuilder) Documentation() AlertingPolicyPathSelectorDocumentation {
	return AlertingPolicyPathSelectorDocumentation{}
}
func (AlertingPolicyFieldPathBuilder) Spec() AlertingPolicyPathSelectorSpec {
	return AlertingPolicyPathSelectorSpec{}
}
func (AlertingPolicyFieldPathBuilder) State() AlertingPolicyPathSelectorState {
	return AlertingPolicyPathSelectorState{}
}

type AlertingPolicyPathSelectorName struct{}

func (AlertingPolicyPathSelectorName) FieldPath() *AlertingPolicy_FieldTerminalPath {
	return &AlertingPolicy_FieldTerminalPath{selector: AlertingPolicy_FieldPathSelectorName}
}

func (s AlertingPolicyPathSelectorName) WithValue(value *Name) *AlertingPolicy_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldTerminalPathValue)
}

func (s AlertingPolicyPathSelectorName) WithArrayOfValues(values []*Name) *AlertingPolicy_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldTerminalPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadata struct{}

func (AlertingPolicyPathSelectorMetadata) FieldPath() *AlertingPolicy_FieldTerminalPath {
	return &AlertingPolicy_FieldTerminalPath{selector: AlertingPolicy_FieldPathSelectorMetadata}
}

func (s AlertingPolicyPathSelectorMetadata) WithValue(value *meta.Meta) *AlertingPolicy_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldTerminalPathValue)
}

func (s AlertingPolicyPathSelectorMetadata) WithArrayOfValues(values []*meta.Meta) *AlertingPolicy_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldTerminalPathArrayOfValues)
}

func (AlertingPolicyPathSelectorMetadata) WithSubPath(subPath meta.Meta_FieldPath) *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{selector: AlertingPolicy_FieldPathSelectorMetadata, subPath: subPath}
}

func (s AlertingPolicyPathSelectorMetadata) WithSubValue(subPathValue meta.Meta_FieldPathValue) *AlertingPolicy_FieldSubPathValue {
	return &AlertingPolicy_FieldSubPathValue{AlertingPolicy_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertingPolicyPathSelectorMetadata) WithSubArrayOfValues(subPathArrayOfValues meta.Meta_FieldPathArrayOfValues) *AlertingPolicy_FieldSubPathArrayOfValues {
	return &AlertingPolicy_FieldSubPathArrayOfValues{AlertingPolicy_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertingPolicyPathSelectorMetadata) WithSubArrayItemValue(subPathArrayItemValue meta.Meta_FieldPathArrayItemValue) *AlertingPolicy_FieldSubPathArrayItemValue {
	return &AlertingPolicy_FieldSubPathArrayItemValue{AlertingPolicy_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertingPolicyPathSelectorMetadata) CreateTime() AlertingPolicyPathSelectorMetadataCreateTime {
	return AlertingPolicyPathSelectorMetadataCreateTime{}
}

func (AlertingPolicyPathSelectorMetadata) UpdateTime() AlertingPolicyPathSelectorMetadataUpdateTime {
	return AlertingPolicyPathSelectorMetadataUpdateTime{}
}

func (AlertingPolicyPathSelectorMetadata) DeleteTime() AlertingPolicyPathSelectorMetadataDeleteTime {
	return AlertingPolicyPathSelectorMetadataDeleteTime{}
}

func (AlertingPolicyPathSelectorMetadata) Uuid() AlertingPolicyPathSelectorMetadataUuid {
	return AlertingPolicyPathSelectorMetadataUuid{}
}

func (AlertingPolicyPathSelectorMetadata) Tags() AlertingPolicyPathSelectorMetadataTags {
	return AlertingPolicyPathSelectorMetadataTags{}
}

func (AlertingPolicyPathSelectorMetadata) Labels() AlertingPolicyPathSelectorMetadataLabels {
	return AlertingPolicyPathSelectorMetadataLabels{}
}

func (AlertingPolicyPathSelectorMetadata) Annotations() AlertingPolicyPathSelectorMetadataAnnotations {
	return AlertingPolicyPathSelectorMetadataAnnotations{}
}

func (AlertingPolicyPathSelectorMetadata) Generation() AlertingPolicyPathSelectorMetadataGeneration {
	return AlertingPolicyPathSelectorMetadataGeneration{}
}

func (AlertingPolicyPathSelectorMetadata) ResourceVersion() AlertingPolicyPathSelectorMetadataResourceVersion {
	return AlertingPolicyPathSelectorMetadataResourceVersion{}
}

func (AlertingPolicyPathSelectorMetadata) OwnerReferences() AlertingPolicyPathSelectorMetadataOwnerReferences {
	return AlertingPolicyPathSelectorMetadataOwnerReferences{}
}

func (AlertingPolicyPathSelectorMetadata) Shards() AlertingPolicyPathSelectorMetadataShards {
	return AlertingPolicyPathSelectorMetadataShards{}
}

func (AlertingPolicyPathSelectorMetadata) Syncing() AlertingPolicyPathSelectorMetadataSyncing {
	return AlertingPolicyPathSelectorMetadataSyncing{}
}

func (AlertingPolicyPathSelectorMetadata) Lifecycle() AlertingPolicyPathSelectorMetadataLifecycle {
	return AlertingPolicyPathSelectorMetadataLifecycle{}
}

func (AlertingPolicyPathSelectorMetadata) Services() AlertingPolicyPathSelectorMetadataServices {
	return AlertingPolicyPathSelectorMetadataServices{}
}

type AlertingPolicyPathSelectorMetadataCreateTime struct{}

func (AlertingPolicyPathSelectorMetadataCreateTime) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().CreateTime().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataCreateTime) WithValue(value *timestamppb.Timestamp) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataCreateTime) WithArrayOfValues(values []*timestamppb.Timestamp) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataUpdateTime struct{}

func (AlertingPolicyPathSelectorMetadataUpdateTime) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().UpdateTime().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataUpdateTime) WithValue(value *timestamppb.Timestamp) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataUpdateTime) WithArrayOfValues(values []*timestamppb.Timestamp) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataDeleteTime struct{}

func (AlertingPolicyPathSelectorMetadataDeleteTime) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().DeleteTime().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataDeleteTime) WithValue(value *timestamppb.Timestamp) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataDeleteTime) WithArrayOfValues(values []*timestamppb.Timestamp) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataUuid struct{}

func (AlertingPolicyPathSelectorMetadataUuid) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Uuid().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataUuid) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataUuid) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataTags struct{}

func (AlertingPolicyPathSelectorMetadataTags) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Tags().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataTags) WithValue(value []string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataTags) WithArrayOfValues(values [][]string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (s AlertingPolicyPathSelectorMetadataTags) WithItemValue(value string) *AlertingPolicy_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertingPolicy_FieldSubPathArrayItemValue)
}

type AlertingPolicyPathSelectorMetadataLabels struct{}

func (AlertingPolicyPathSelectorMetadataLabels) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataLabels) WithValue(value map[string]string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataLabels) WithArrayOfValues(values []map[string]string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (AlertingPolicyPathSelectorMetadataLabels) WithKey(key string) AlertingPolicyMapPathSelectorMetadataLabels {
	return AlertingPolicyMapPathSelectorMetadataLabels{key: key}
}

type AlertingPolicyMapPathSelectorMetadataLabels struct {
	key string
}

func (s AlertingPolicyMapPathSelectorMetadataLabels) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s AlertingPolicyMapPathSelectorMetadataLabels) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyMapPathSelectorMetadataLabels) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataAnnotations struct{}

func (AlertingPolicyPathSelectorMetadataAnnotations) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataAnnotations) WithValue(value map[string]string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataAnnotations) WithArrayOfValues(values []map[string]string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (AlertingPolicyPathSelectorMetadataAnnotations) WithKey(key string) AlertingPolicyMapPathSelectorMetadataAnnotations {
	return AlertingPolicyMapPathSelectorMetadataAnnotations{key: key}
}

type AlertingPolicyMapPathSelectorMetadataAnnotations struct {
	key string
}

func (s AlertingPolicyMapPathSelectorMetadataAnnotations) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().WithKey(s.key).FieldPath(),
	}
}

func (s AlertingPolicyMapPathSelectorMetadataAnnotations) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyMapPathSelectorMetadataAnnotations) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataGeneration struct{}

func (AlertingPolicyPathSelectorMetadataGeneration) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Generation().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataGeneration) WithValue(value int64) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataGeneration) WithArrayOfValues(values []int64) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataResourceVersion struct{}

func (AlertingPolicyPathSelectorMetadataResourceVersion) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().ResourceVersion().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataResourceVersion) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataResourceVersion) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataOwnerReferences struct{}

func (AlertingPolicyPathSelectorMetadataOwnerReferences) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferences) WithValue(value []*meta.OwnerReference) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferences) WithArrayOfValues(values [][]*meta.OwnerReference) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferences) WithItemValue(value *meta.OwnerReference) *AlertingPolicy_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertingPolicy_FieldSubPathArrayItemValue)
}

func (AlertingPolicyPathSelectorMetadataOwnerReferences) Kind() AlertingPolicyPathSelectorMetadataOwnerReferencesKind {
	return AlertingPolicyPathSelectorMetadataOwnerReferencesKind{}
}

func (AlertingPolicyPathSelectorMetadataOwnerReferences) Version() AlertingPolicyPathSelectorMetadataOwnerReferencesVersion {
	return AlertingPolicyPathSelectorMetadataOwnerReferencesVersion{}
}

func (AlertingPolicyPathSelectorMetadataOwnerReferences) Name() AlertingPolicyPathSelectorMetadataOwnerReferencesName {
	return AlertingPolicyPathSelectorMetadataOwnerReferencesName{}
}

func (AlertingPolicyPathSelectorMetadataOwnerReferences) Region() AlertingPolicyPathSelectorMetadataOwnerReferencesRegion {
	return AlertingPolicyPathSelectorMetadataOwnerReferencesRegion{}
}

func (AlertingPolicyPathSelectorMetadataOwnerReferences) Controller() AlertingPolicyPathSelectorMetadataOwnerReferencesController {
	return AlertingPolicyPathSelectorMetadataOwnerReferencesController{}
}

func (AlertingPolicyPathSelectorMetadataOwnerReferences) RequiresOwnerReference() AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference {
	return AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference{}
}

type AlertingPolicyPathSelectorMetadataOwnerReferencesKind struct{}

func (AlertingPolicyPathSelectorMetadataOwnerReferencesKind) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Kind().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesKind) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesKind) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataOwnerReferencesVersion struct{}

func (AlertingPolicyPathSelectorMetadataOwnerReferencesVersion) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Version().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesVersion) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesVersion) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataOwnerReferencesName struct{}

func (AlertingPolicyPathSelectorMetadataOwnerReferencesName) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Name().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesName) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesName) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataOwnerReferencesRegion struct{}

func (AlertingPolicyPathSelectorMetadataOwnerReferencesRegion) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Region().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesRegion) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesRegion) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataOwnerReferencesController struct{}

func (AlertingPolicyPathSelectorMetadataOwnerReferencesController) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Controller().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesController) WithValue(value bool) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesController) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference struct{}

func (AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().RequiresOwnerReference().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithValue(value bool) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataShards struct{}

func (AlertingPolicyPathSelectorMetadataShards) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataShards) WithValue(value map[string]int64) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataShards) WithArrayOfValues(values []map[string]int64) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (AlertingPolicyPathSelectorMetadataShards) WithKey(key string) AlertingPolicyMapPathSelectorMetadataShards {
	return AlertingPolicyMapPathSelectorMetadataShards{key: key}
}

type AlertingPolicyMapPathSelectorMetadataShards struct {
	key string
}

func (s AlertingPolicyMapPathSelectorMetadataShards) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().WithKey(s.key).FieldPath(),
	}
}

func (s AlertingPolicyMapPathSelectorMetadataShards) WithValue(value int64) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyMapPathSelectorMetadataShards) WithArrayOfValues(values []int64) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataSyncing struct{}

func (AlertingPolicyPathSelectorMetadataSyncing) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataSyncing) WithValue(value *meta.SyncingMeta) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataSyncing) WithArrayOfValues(values []*meta.SyncingMeta) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (AlertingPolicyPathSelectorMetadataSyncing) OwningRegion() AlertingPolicyPathSelectorMetadataSyncingOwningRegion {
	return AlertingPolicyPathSelectorMetadataSyncingOwningRegion{}
}

func (AlertingPolicyPathSelectorMetadataSyncing) Regions() AlertingPolicyPathSelectorMetadataSyncingRegions {
	return AlertingPolicyPathSelectorMetadataSyncingRegions{}
}

type AlertingPolicyPathSelectorMetadataSyncingOwningRegion struct{}

func (AlertingPolicyPathSelectorMetadataSyncingOwningRegion) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().OwningRegion().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataSyncingOwningRegion) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataSyncingOwningRegion) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataSyncingRegions struct{}

func (AlertingPolicyPathSelectorMetadataSyncingRegions) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().Regions().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataSyncingRegions) WithValue(value []string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataSyncingRegions) WithArrayOfValues(values [][]string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (s AlertingPolicyPathSelectorMetadataSyncingRegions) WithItemValue(value string) *AlertingPolicy_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertingPolicy_FieldSubPathArrayItemValue)
}

type AlertingPolicyPathSelectorMetadataLifecycle struct{}

func (AlertingPolicyPathSelectorMetadataLifecycle) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataLifecycle) WithValue(value *meta.Lifecycle) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataLifecycle) WithArrayOfValues(values []*meta.Lifecycle) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (AlertingPolicyPathSelectorMetadataLifecycle) State() AlertingPolicyPathSelectorMetadataLifecycleState {
	return AlertingPolicyPathSelectorMetadataLifecycleState{}
}

func (AlertingPolicyPathSelectorMetadataLifecycle) BlockDeletion() AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion {
	return AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion{}
}

type AlertingPolicyPathSelectorMetadataLifecycleState struct{}

func (AlertingPolicyPathSelectorMetadataLifecycleState) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().State().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataLifecycleState) WithValue(value meta.Lifecycle_State) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataLifecycleState) WithArrayOfValues(values []meta.Lifecycle_State) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion struct{}

func (AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().BlockDeletion().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion) WithValue(value bool) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataServices struct{}

func (AlertingPolicyPathSelectorMetadataServices) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataServices) WithValue(value *meta.ServicesInfo) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataServices) WithArrayOfValues(values []*meta.ServicesInfo) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (AlertingPolicyPathSelectorMetadataServices) OwningService() AlertingPolicyPathSelectorMetadataServicesOwningService {
	return AlertingPolicyPathSelectorMetadataServicesOwningService{}
}

func (AlertingPolicyPathSelectorMetadataServices) AllowedServices() AlertingPolicyPathSelectorMetadataServicesAllowedServices {
	return AlertingPolicyPathSelectorMetadataServicesAllowedServices{}
}

type AlertingPolicyPathSelectorMetadataServicesOwningService struct{}

func (AlertingPolicyPathSelectorMetadataServicesOwningService) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().OwningService().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataServicesOwningService) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataServicesOwningService) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorMetadataServicesAllowedServices struct{}

func (AlertingPolicyPathSelectorMetadataServicesAllowedServices) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().AllowedServices().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorMetadataServicesAllowedServices) WithValue(value []string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorMetadataServicesAllowedServices) WithArrayOfValues(values [][]string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (s AlertingPolicyPathSelectorMetadataServicesAllowedServices) WithItemValue(value string) *AlertingPolicy_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertingPolicy_FieldSubPathArrayItemValue)
}

type AlertingPolicyPathSelectorDisplayName struct{}

func (AlertingPolicyPathSelectorDisplayName) FieldPath() *AlertingPolicy_FieldTerminalPath {
	return &AlertingPolicy_FieldTerminalPath{selector: AlertingPolicy_FieldPathSelectorDisplayName}
}

func (s AlertingPolicyPathSelectorDisplayName) WithValue(value string) *AlertingPolicy_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldTerminalPathValue)
}

func (s AlertingPolicyPathSelectorDisplayName) WithArrayOfValues(values []string) *AlertingPolicy_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldTerminalPathArrayOfValues)
}

type AlertingPolicyPathSelectorDescription struct{}

func (AlertingPolicyPathSelectorDescription) FieldPath() *AlertingPolicy_FieldTerminalPath {
	return &AlertingPolicy_FieldTerminalPath{selector: AlertingPolicy_FieldPathSelectorDescription}
}

func (s AlertingPolicyPathSelectorDescription) WithValue(value string) *AlertingPolicy_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldTerminalPathValue)
}

func (s AlertingPolicyPathSelectorDescription) WithArrayOfValues(values []string) *AlertingPolicy_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldTerminalPathArrayOfValues)
}

type AlertingPolicyPathSelectorDocumentation struct{}

func (AlertingPolicyPathSelectorDocumentation) FieldPath() *AlertingPolicy_FieldTerminalPath {
	return &AlertingPolicy_FieldTerminalPath{selector: AlertingPolicy_FieldPathSelectorDocumentation}
}

func (s AlertingPolicyPathSelectorDocumentation) WithValue(value *AlertingPolicy_Documentation) *AlertingPolicy_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldTerminalPathValue)
}

func (s AlertingPolicyPathSelectorDocumentation) WithArrayOfValues(values []*AlertingPolicy_Documentation) *AlertingPolicy_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldTerminalPathArrayOfValues)
}

func (AlertingPolicyPathSelectorDocumentation) WithSubPath(subPath AlertingPolicyDocumentation_FieldPath) *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{selector: AlertingPolicy_FieldPathSelectorDocumentation, subPath: subPath}
}

func (s AlertingPolicyPathSelectorDocumentation) WithSubValue(subPathValue AlertingPolicyDocumentation_FieldPathValue) *AlertingPolicy_FieldSubPathValue {
	return &AlertingPolicy_FieldSubPathValue{AlertingPolicy_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertingPolicyPathSelectorDocumentation) WithSubArrayOfValues(subPathArrayOfValues AlertingPolicyDocumentation_FieldPathArrayOfValues) *AlertingPolicy_FieldSubPathArrayOfValues {
	return &AlertingPolicy_FieldSubPathArrayOfValues{AlertingPolicy_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertingPolicyPathSelectorDocumentation) WithSubArrayItemValue(subPathArrayItemValue AlertingPolicyDocumentation_FieldPathArrayItemValue) *AlertingPolicy_FieldSubPathArrayItemValue {
	return &AlertingPolicy_FieldSubPathArrayItemValue{AlertingPolicy_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertingPolicyPathSelectorDocumentation) Content() AlertingPolicyPathSelectorDocumentationContent {
	return AlertingPolicyPathSelectorDocumentationContent{}
}

func (AlertingPolicyPathSelectorDocumentation) MimeType() AlertingPolicyPathSelectorDocumentationMimeType {
	return AlertingPolicyPathSelectorDocumentationMimeType{}
}

type AlertingPolicyPathSelectorDocumentationContent struct{}

func (AlertingPolicyPathSelectorDocumentationContent) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorDocumentation,
		subPath:  NewAlertingPolicyDocumentationFieldPathBuilder().Content().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorDocumentationContent) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorDocumentationContent) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorDocumentationMimeType struct{}

func (AlertingPolicyPathSelectorDocumentationMimeType) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorDocumentation,
		subPath:  NewAlertingPolicyDocumentationFieldPathBuilder().MimeType().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorDocumentationMimeType) WithValue(value string) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorDocumentationMimeType) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorSpec struct{}

func (AlertingPolicyPathSelectorSpec) FieldPath() *AlertingPolicy_FieldTerminalPath {
	return &AlertingPolicy_FieldTerminalPath{selector: AlertingPolicy_FieldPathSelectorSpec}
}

func (s AlertingPolicyPathSelectorSpec) WithValue(value *AlertingPolicy_Spec) *AlertingPolicy_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldTerminalPathValue)
}

func (s AlertingPolicyPathSelectorSpec) WithArrayOfValues(values []*AlertingPolicy_Spec) *AlertingPolicy_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldTerminalPathArrayOfValues)
}

func (AlertingPolicyPathSelectorSpec) WithSubPath(subPath AlertingPolicySpec_FieldPath) *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{selector: AlertingPolicy_FieldPathSelectorSpec, subPath: subPath}
}

func (s AlertingPolicyPathSelectorSpec) WithSubValue(subPathValue AlertingPolicySpec_FieldPathValue) *AlertingPolicy_FieldSubPathValue {
	return &AlertingPolicy_FieldSubPathValue{AlertingPolicy_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertingPolicyPathSelectorSpec) WithSubArrayOfValues(subPathArrayOfValues AlertingPolicySpec_FieldPathArrayOfValues) *AlertingPolicy_FieldSubPathArrayOfValues {
	return &AlertingPolicy_FieldSubPathArrayOfValues{AlertingPolicy_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertingPolicyPathSelectorSpec) WithSubArrayItemValue(subPathArrayItemValue AlertingPolicySpec_FieldPathArrayItemValue) *AlertingPolicy_FieldSubPathArrayItemValue {
	return &AlertingPolicy_FieldSubPathArrayItemValue{AlertingPolicy_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertingPolicyPathSelectorSpec) Enabled() AlertingPolicyPathSelectorSpecEnabled {
	return AlertingPolicyPathSelectorSpecEnabled{}
}

func (AlertingPolicyPathSelectorSpec) ConditionCombiner() AlertingPolicyPathSelectorSpecConditionCombiner {
	return AlertingPolicyPathSelectorSpecConditionCombiner{}
}

func (AlertingPolicyPathSelectorSpec) Notification() AlertingPolicyPathSelectorSpecNotification {
	return AlertingPolicyPathSelectorSpecNotification{}
}

type AlertingPolicyPathSelectorSpecEnabled struct{}

func (AlertingPolicyPathSelectorSpecEnabled) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorSpec,
		subPath:  NewAlertingPolicySpecFieldPathBuilder().Enabled().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorSpecEnabled) WithValue(value bool) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorSpecEnabled) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorSpecConditionCombiner struct{}

func (AlertingPolicyPathSelectorSpecConditionCombiner) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorSpec,
		subPath:  NewAlertingPolicySpecFieldPathBuilder().ConditionCombiner().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorSpecConditionCombiner) WithValue(value AlertingPolicy_Spec_ConditionsCombiner) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorSpecConditionCombiner) WithArrayOfValues(values []AlertingPolicy_Spec_ConditionsCombiner) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorSpecNotification struct{}

func (AlertingPolicyPathSelectorSpecNotification) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorSpec,
		subPath:  NewAlertingPolicySpecFieldPathBuilder().Notification().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorSpecNotification) WithValue(value *AlertingPolicy_Spec_Notification) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorSpecNotification) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (AlertingPolicyPathSelectorSpecNotification) Enabled() AlertingPolicyPathSelectorSpecNotificationEnabled {
	return AlertingPolicyPathSelectorSpecNotificationEnabled{}
}

func (AlertingPolicyPathSelectorSpecNotification) Channels() AlertingPolicyPathSelectorSpecNotificationChannels {
	return AlertingPolicyPathSelectorSpecNotificationChannels{}
}

type AlertingPolicyPathSelectorSpecNotificationEnabled struct{}

func (AlertingPolicyPathSelectorSpecNotificationEnabled) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorSpec,
		subPath:  NewAlertingPolicySpecFieldPathBuilder().Notification().Enabled().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorSpecNotificationEnabled) WithValue(value bool) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorSpecNotificationEnabled) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyPathSelectorSpecNotificationChannels struct{}

func (AlertingPolicyPathSelectorSpecNotificationChannels) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorSpec,
		subPath:  NewAlertingPolicySpecFieldPathBuilder().Notification().Channels().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorSpecNotificationChannels) WithValue(value []*notification_channel.Reference) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorSpecNotificationChannels) WithArrayOfValues(values [][]*notification_channel.Reference) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

func (s AlertingPolicyPathSelectorSpecNotificationChannels) WithItemValue(value *notification_channel.Reference) *AlertingPolicy_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertingPolicy_FieldSubPathArrayItemValue)
}

type AlertingPolicyPathSelectorState struct{}

func (AlertingPolicyPathSelectorState) FieldPath() *AlertingPolicy_FieldTerminalPath {
	return &AlertingPolicy_FieldTerminalPath{selector: AlertingPolicy_FieldPathSelectorState}
}

func (s AlertingPolicyPathSelectorState) WithValue(value *AlertingPolicy_State) *AlertingPolicy_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldTerminalPathValue)
}

func (s AlertingPolicyPathSelectorState) WithArrayOfValues(values []*AlertingPolicy_State) *AlertingPolicy_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldTerminalPathArrayOfValues)
}

func (AlertingPolicyPathSelectorState) WithSubPath(subPath AlertingPolicyState_FieldPath) *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{selector: AlertingPolicy_FieldPathSelectorState, subPath: subPath}
}

func (s AlertingPolicyPathSelectorState) WithSubValue(subPathValue AlertingPolicyState_FieldPathValue) *AlertingPolicy_FieldSubPathValue {
	return &AlertingPolicy_FieldSubPathValue{AlertingPolicy_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertingPolicyPathSelectorState) WithSubArrayOfValues(subPathArrayOfValues AlertingPolicyState_FieldPathArrayOfValues) *AlertingPolicy_FieldSubPathArrayOfValues {
	return &AlertingPolicy_FieldSubPathArrayOfValues{AlertingPolicy_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertingPolicyPathSelectorState) WithSubArrayItemValue(subPathArrayItemValue AlertingPolicyState_FieldPathArrayItemValue) *AlertingPolicy_FieldSubPathArrayItemValue {
	return &AlertingPolicy_FieldSubPathArrayItemValue{AlertingPolicy_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertingPolicyPathSelectorState) ActiveAlertsCount() AlertingPolicyPathSelectorStateActiveAlertsCount {
	return AlertingPolicyPathSelectorStateActiveAlertsCount{}
}

type AlertingPolicyPathSelectorStateActiveAlertsCount struct{}

func (AlertingPolicyPathSelectorStateActiveAlertsCount) FieldPath() *AlertingPolicy_FieldSubPath {
	return &AlertingPolicy_FieldSubPath{
		selector: AlertingPolicy_FieldPathSelectorState,
		subPath:  NewAlertingPolicyStateFieldPathBuilder().ActiveAlertsCount().FieldPath(),
	}
}

func (s AlertingPolicyPathSelectorStateActiveAlertsCount) WithValue(value int64) *AlertingPolicy_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicy_FieldSubPathValue)
}

func (s AlertingPolicyPathSelectorStateActiveAlertsCount) WithArrayOfValues(values []int64) *AlertingPolicy_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicy_FieldSubPathArrayOfValues)
}

type AlertingPolicyDocumentationFieldPathBuilder struct{}

func NewAlertingPolicyDocumentationFieldPathBuilder() AlertingPolicyDocumentationFieldPathBuilder {
	return AlertingPolicyDocumentationFieldPathBuilder{}
}
func (AlertingPolicyDocumentationFieldPathBuilder) Content() AlertingPolicy_DocumentationPathSelectorContent {
	return AlertingPolicy_DocumentationPathSelectorContent{}
}
func (AlertingPolicyDocumentationFieldPathBuilder) MimeType() AlertingPolicy_DocumentationPathSelectorMimeType {
	return AlertingPolicy_DocumentationPathSelectorMimeType{}
}

type AlertingPolicy_DocumentationPathSelectorContent struct{}

func (AlertingPolicy_DocumentationPathSelectorContent) FieldPath() *AlertingPolicyDocumentation_FieldTerminalPath {
	return &AlertingPolicyDocumentation_FieldTerminalPath{selector: AlertingPolicyDocumentation_FieldPathSelectorContent}
}

func (s AlertingPolicy_DocumentationPathSelectorContent) WithValue(value string) *AlertingPolicyDocumentation_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicyDocumentation_FieldTerminalPathValue)
}

func (s AlertingPolicy_DocumentationPathSelectorContent) WithArrayOfValues(values []string) *AlertingPolicyDocumentation_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicyDocumentation_FieldTerminalPathArrayOfValues)
}

type AlertingPolicy_DocumentationPathSelectorMimeType struct{}

func (AlertingPolicy_DocumentationPathSelectorMimeType) FieldPath() *AlertingPolicyDocumentation_FieldTerminalPath {
	return &AlertingPolicyDocumentation_FieldTerminalPath{selector: AlertingPolicyDocumentation_FieldPathSelectorMimeType}
}

func (s AlertingPolicy_DocumentationPathSelectorMimeType) WithValue(value string) *AlertingPolicyDocumentation_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicyDocumentation_FieldTerminalPathValue)
}

func (s AlertingPolicy_DocumentationPathSelectorMimeType) WithArrayOfValues(values []string) *AlertingPolicyDocumentation_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicyDocumentation_FieldTerminalPathArrayOfValues)
}

type AlertingPolicySpecFieldPathBuilder struct{}

func NewAlertingPolicySpecFieldPathBuilder() AlertingPolicySpecFieldPathBuilder {
	return AlertingPolicySpecFieldPathBuilder{}
}
func (AlertingPolicySpecFieldPathBuilder) Enabled() AlertingPolicy_SpecPathSelectorEnabled {
	return AlertingPolicy_SpecPathSelectorEnabled{}
}
func (AlertingPolicySpecFieldPathBuilder) ConditionCombiner() AlertingPolicy_SpecPathSelectorConditionCombiner {
	return AlertingPolicy_SpecPathSelectorConditionCombiner{}
}
func (AlertingPolicySpecFieldPathBuilder) Notification() AlertingPolicy_SpecPathSelectorNotification {
	return AlertingPolicy_SpecPathSelectorNotification{}
}

type AlertingPolicy_SpecPathSelectorEnabled struct{}

func (AlertingPolicy_SpecPathSelectorEnabled) FieldPath() *AlertingPolicySpec_FieldTerminalPath {
	return &AlertingPolicySpec_FieldTerminalPath{selector: AlertingPolicySpec_FieldPathSelectorEnabled}
}

func (s AlertingPolicy_SpecPathSelectorEnabled) WithValue(value bool) *AlertingPolicySpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicySpec_FieldTerminalPathValue)
}

func (s AlertingPolicy_SpecPathSelectorEnabled) WithArrayOfValues(values []bool) *AlertingPolicySpec_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicySpec_FieldTerminalPathArrayOfValues)
}

type AlertingPolicy_SpecPathSelectorConditionCombiner struct{}

func (AlertingPolicy_SpecPathSelectorConditionCombiner) FieldPath() *AlertingPolicySpec_FieldTerminalPath {
	return &AlertingPolicySpec_FieldTerminalPath{selector: AlertingPolicySpec_FieldPathSelectorConditionCombiner}
}

func (s AlertingPolicy_SpecPathSelectorConditionCombiner) WithValue(value AlertingPolicy_Spec_ConditionsCombiner) *AlertingPolicySpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicySpec_FieldTerminalPathValue)
}

func (s AlertingPolicy_SpecPathSelectorConditionCombiner) WithArrayOfValues(values []AlertingPolicy_Spec_ConditionsCombiner) *AlertingPolicySpec_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicySpec_FieldTerminalPathArrayOfValues)
}

type AlertingPolicy_SpecPathSelectorNotification struct{}

func (AlertingPolicy_SpecPathSelectorNotification) FieldPath() *AlertingPolicySpec_FieldTerminalPath {
	return &AlertingPolicySpec_FieldTerminalPath{selector: AlertingPolicySpec_FieldPathSelectorNotification}
}

func (s AlertingPolicy_SpecPathSelectorNotification) WithValue(value *AlertingPolicy_Spec_Notification) *AlertingPolicySpec_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicySpec_FieldTerminalPathValue)
}

func (s AlertingPolicy_SpecPathSelectorNotification) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification) *AlertingPolicySpec_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicySpec_FieldTerminalPathArrayOfValues)
}

func (AlertingPolicy_SpecPathSelectorNotification) WithSubPath(subPath AlertingPolicySpecNotification_FieldPath) *AlertingPolicySpec_FieldSubPath {
	return &AlertingPolicySpec_FieldSubPath{selector: AlertingPolicySpec_FieldPathSelectorNotification, subPath: subPath}
}

func (s AlertingPolicy_SpecPathSelectorNotification) WithSubValue(subPathValue AlertingPolicySpecNotification_FieldPathValue) *AlertingPolicySpec_FieldSubPathValue {
	return &AlertingPolicySpec_FieldSubPathValue{AlertingPolicySpec_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s AlertingPolicy_SpecPathSelectorNotification) WithSubArrayOfValues(subPathArrayOfValues AlertingPolicySpecNotification_FieldPathArrayOfValues) *AlertingPolicySpec_FieldSubPathArrayOfValues {
	return &AlertingPolicySpec_FieldSubPathArrayOfValues{AlertingPolicySpec_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s AlertingPolicy_SpecPathSelectorNotification) WithSubArrayItemValue(subPathArrayItemValue AlertingPolicySpecNotification_FieldPathArrayItemValue) *AlertingPolicySpec_FieldSubPathArrayItemValue {
	return &AlertingPolicySpec_FieldSubPathArrayItemValue{AlertingPolicySpec_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (AlertingPolicy_SpecPathSelectorNotification) Enabled() AlertingPolicy_SpecPathSelectorNotificationEnabled {
	return AlertingPolicy_SpecPathSelectorNotificationEnabled{}
}

func (AlertingPolicy_SpecPathSelectorNotification) Channels() AlertingPolicy_SpecPathSelectorNotificationChannels {
	return AlertingPolicy_SpecPathSelectorNotificationChannels{}
}

type AlertingPolicy_SpecPathSelectorNotificationEnabled struct{}

func (AlertingPolicy_SpecPathSelectorNotificationEnabled) FieldPath() *AlertingPolicySpec_FieldSubPath {
	return &AlertingPolicySpec_FieldSubPath{
		selector: AlertingPolicySpec_FieldPathSelectorNotification,
		subPath:  NewAlertingPolicySpecNotificationFieldPathBuilder().Enabled().FieldPath(),
	}
}

func (s AlertingPolicy_SpecPathSelectorNotificationEnabled) WithValue(value bool) *AlertingPolicySpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicySpec_FieldSubPathValue)
}

func (s AlertingPolicy_SpecPathSelectorNotificationEnabled) WithArrayOfValues(values []bool) *AlertingPolicySpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicySpec_FieldSubPathArrayOfValues)
}

type AlertingPolicy_SpecPathSelectorNotificationChannels struct{}

func (AlertingPolicy_SpecPathSelectorNotificationChannels) FieldPath() *AlertingPolicySpec_FieldSubPath {
	return &AlertingPolicySpec_FieldSubPath{
		selector: AlertingPolicySpec_FieldPathSelectorNotification,
		subPath:  NewAlertingPolicySpecNotificationFieldPathBuilder().Channels().FieldPath(),
	}
}

func (s AlertingPolicy_SpecPathSelectorNotificationChannels) WithValue(value []*notification_channel.Reference) *AlertingPolicySpec_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicySpec_FieldSubPathValue)
}

func (s AlertingPolicy_SpecPathSelectorNotificationChannels) WithArrayOfValues(values [][]*notification_channel.Reference) *AlertingPolicySpec_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicySpec_FieldSubPathArrayOfValues)
}

func (s AlertingPolicy_SpecPathSelectorNotificationChannels) WithItemValue(value *notification_channel.Reference) *AlertingPolicySpec_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertingPolicySpec_FieldSubPathArrayItemValue)
}

type AlertingPolicyStateFieldPathBuilder struct{}

func NewAlertingPolicyStateFieldPathBuilder() AlertingPolicyStateFieldPathBuilder {
	return AlertingPolicyStateFieldPathBuilder{}
}
func (AlertingPolicyStateFieldPathBuilder) ActiveAlertsCount() AlertingPolicy_StatePathSelectorActiveAlertsCount {
	return AlertingPolicy_StatePathSelectorActiveAlertsCount{}
}

type AlertingPolicy_StatePathSelectorActiveAlertsCount struct{}

func (AlertingPolicy_StatePathSelectorActiveAlertsCount) FieldPath() *AlertingPolicyState_FieldTerminalPath {
	return &AlertingPolicyState_FieldTerminalPath{selector: AlertingPolicyState_FieldPathSelectorActiveAlertsCount}
}

func (s AlertingPolicy_StatePathSelectorActiveAlertsCount) WithValue(value int64) *AlertingPolicyState_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicyState_FieldTerminalPathValue)
}

func (s AlertingPolicy_StatePathSelectorActiveAlertsCount) WithArrayOfValues(values []int64) *AlertingPolicyState_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicyState_FieldTerminalPathArrayOfValues)
}

type AlertingPolicySpecNotificationFieldPathBuilder struct{}

func NewAlertingPolicySpecNotificationFieldPathBuilder() AlertingPolicySpecNotificationFieldPathBuilder {
	return AlertingPolicySpecNotificationFieldPathBuilder{}
}
func (AlertingPolicySpecNotificationFieldPathBuilder) Enabled() AlertingPolicy_Spec_NotificationPathSelectorEnabled {
	return AlertingPolicy_Spec_NotificationPathSelectorEnabled{}
}
func (AlertingPolicySpecNotificationFieldPathBuilder) Channels() AlertingPolicy_Spec_NotificationPathSelectorChannels {
	return AlertingPolicy_Spec_NotificationPathSelectorChannels{}
}

type AlertingPolicy_Spec_NotificationPathSelectorEnabled struct{}

func (AlertingPolicy_Spec_NotificationPathSelectorEnabled) FieldPath() *AlertingPolicySpecNotification_FieldTerminalPath {
	return &AlertingPolicySpecNotification_FieldTerminalPath{selector: AlertingPolicySpecNotification_FieldPathSelectorEnabled}
}

func (s AlertingPolicy_Spec_NotificationPathSelectorEnabled) WithValue(value bool) *AlertingPolicySpecNotification_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicySpecNotification_FieldTerminalPathValue)
}

func (s AlertingPolicy_Spec_NotificationPathSelectorEnabled) WithArrayOfValues(values []bool) *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues)
}

type AlertingPolicy_Spec_NotificationPathSelectorChannels struct{}

func (AlertingPolicy_Spec_NotificationPathSelectorChannels) FieldPath() *AlertingPolicySpecNotification_FieldTerminalPath {
	return &AlertingPolicySpecNotification_FieldTerminalPath{selector: AlertingPolicySpecNotification_FieldPathSelectorChannels}
}

func (s AlertingPolicy_Spec_NotificationPathSelectorChannels) WithValue(value []*notification_channel.Reference) *AlertingPolicySpecNotification_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*AlertingPolicySpecNotification_FieldTerminalPathValue)
}

func (s AlertingPolicy_Spec_NotificationPathSelectorChannels) WithArrayOfValues(values [][]*notification_channel.Reference) *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues)
}

func (s AlertingPolicy_Spec_NotificationPathSelectorChannels) WithItemValue(value *notification_channel.Reference) *AlertingPolicySpecNotification_FieldTerminalPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*AlertingPolicySpecNotification_FieldTerminalPathArrayItemValue)
}