alerting_policy_service.pb.descriptors.go

// Code generated by protoc-gen-goten-client
// API: AlertingPolicyService
// DO NOT EDIT!!!

package alerting_policy_client

import (
	"google.golang.org/protobuf/proto"

	gotenclient "github.com/cloudwan/goten-sdk/runtime/client"
	gotenresource "github.com/cloudwan/goten-sdk/runtime/resource"
)

// proto imports
import (
	alerting_policy "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alerting_policy"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = new(proto.Message)
	_ = new(gotenclient.MethodDescriptor)
	_ = gotenresource.WildcardId
)

// make sure we're using proto imports
var (
	_ = &alerting_policy.AlertingPolicy{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized             bool
	alertingPolicyServiceDescriptor    *AlertingPolicyServiceDescriptor
	getAlertingPolicyDescriptor        *GetAlertingPolicyDescriptor
	batchGetAlertingPoliciesDescriptor *BatchGetAlertingPoliciesDescriptor
	listAlertingPoliciesDescriptor     *ListAlertingPoliciesDescriptor
	watchAlertingPolicyDescriptor      *WatchAlertingPolicyDescriptor
	watchAlertingPoliciesDescriptor    *WatchAlertingPoliciesDescriptor
	createAlertingPolicyDescriptor     *CreateAlertingPolicyDescriptor
	updateAlertingPolicyDescriptor     *UpdateAlertingPolicyDescriptor
	deleteAlertingPolicyDescriptor     *DeleteAlertingPolicyDescriptor
	searchAlertingPoliciesDescriptor   *SearchAlertingPoliciesDescriptor
)

type GetAlertingPolicyDescriptor struct{}

type GetAlertingPolicyDescriptorClientMsgHandle struct{}

type GetAlertingPolicyDescriptorServerMsgHandle struct{}

func (d *GetAlertingPolicyDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetAlertingPolicyRequest{}
}

func (d *GetAlertingPolicyDescriptor) NewEmptyServerMsg() proto.Message {
	return &alerting_policy.AlertingPolicy{}
}

func (d *GetAlertingPolicyDescriptor) IsUnary() bool {
	return true
}

func (d *GetAlertingPolicyDescriptor) IsClientStream() bool {
	return false
}

func (d *GetAlertingPolicyDescriptor) IsServerStream() bool {
	return false
}

func (d *GetAlertingPolicyDescriptor) IsCollection() bool {
	return false
}

func (d *GetAlertingPolicyDescriptor) IsPlural() bool {
	return false
}

func (d *GetAlertingPolicyDescriptor) HasResource() bool {
	return true
}

func (d *GetAlertingPolicyDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *GetAlertingPolicyDescriptor) GetVerb() string {
	return "get"
}

func (d *GetAlertingPolicyDescriptor) GetMethodName() string {
	return "GetAlertingPolicy"
}

func (d *GetAlertingPolicyDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService/GetAlertingPolicy"
}

func (d *GetAlertingPolicyDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *GetAlertingPolicyDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *GetAlertingPolicyDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *GetAlertingPolicyDescriptor) GetServiceVersion() string {
	return "v3"
}

func (d *GetAlertingPolicyDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingPolicyServiceDescriptor
}

func (d *GetAlertingPolicyDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_policy.GetDescriptor()
}

func (d *GetAlertingPolicyDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetAlertingPolicyDescriptorClientMsgHandle{}
}

func (d *GetAlertingPolicyDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetAlertingPolicyDescriptorServerMsgHandle{}
}

func (h *GetAlertingPolicyDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*GetAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*GetAlertingPolicyRequest) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if name := typedMsg.GetName(); name != nil {
			return name
		}
	}
	return (*alerting_policy.Name)(nil)
}

func (h *GetAlertingPolicyDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetAlertingPolicyRequest) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *GetAlertingPolicyDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*GetAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*GetAlertingPolicyRequest) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *GetAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetAlertingPolicyRequest) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetAlertingPolicyRequest) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *GetAlertingPolicyDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*alerting_policy.AlertingPolicy) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if name := typedMsg.GetName(); name != nil {
			return name
		}
	}
	return (*alerting_policy.Name)(nil)
}

func (h *GetAlertingPolicyDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*alerting_policy.AlertingPolicy) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *GetAlertingPolicyDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*alerting_policy.AlertingPolicy) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *GetAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*alerting_policy.AlertingPolicy)
}

func (h *GetAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*alerting_policy.AlertingPolicy) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetAlertingPolicyDescriptor() *GetAlertingPolicyDescriptor {
	return getAlertingPolicyDescriptor
}

type BatchGetAlertingPoliciesDescriptor struct{}

type BatchGetAlertingPoliciesDescriptorClientMsgHandle struct{}

type BatchGetAlertingPoliciesDescriptorServerMsgHandle struct{}

func (d *BatchGetAlertingPoliciesDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetAlertingPoliciesRequest{}
}

func (d *BatchGetAlertingPoliciesDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetAlertingPoliciesResponse{}
}

func (d *BatchGetAlertingPoliciesDescriptor) IsUnary() bool {
	return true
}

func (d *BatchGetAlertingPoliciesDescriptor) IsClientStream() bool {
	return false
}

func (d *BatchGetAlertingPoliciesDescriptor) IsServerStream() bool {
	return false
}

func (d *BatchGetAlertingPoliciesDescriptor) IsCollection() bool {
	return false
}

func (d *BatchGetAlertingPoliciesDescriptor) IsPlural() bool {
	return true
}

func (d *BatchGetAlertingPoliciesDescriptor) HasResource() bool {
	return true
}

func (d *BatchGetAlertingPoliciesDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *BatchGetAlertingPoliciesDescriptor) GetVerb() string {
	return "batchGet"
}

func (d *BatchGetAlertingPoliciesDescriptor) GetMethodName() string {
	return "BatchGetAlertingPolicies"
}

func (d *BatchGetAlertingPoliciesDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService/BatchGetAlertingPolicies"
}

func (d *BatchGetAlertingPoliciesDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *BatchGetAlertingPoliciesDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *BatchGetAlertingPoliciesDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *BatchGetAlertingPoliciesDescriptor) GetServiceVersion() string {
	return "v3"
}

func (d *BatchGetAlertingPoliciesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingPolicyServiceDescriptor
}

func (d *BatchGetAlertingPoliciesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_policy.GetDescriptor()
}

func (d *BatchGetAlertingPoliciesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetAlertingPoliciesDescriptorClientMsgHandle{}
}

func (d *BatchGetAlertingPoliciesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetAlertingPoliciesDescriptorServerMsgHandle{}
}

func (h *BatchGetAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*BatchGetAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*BatchGetAlertingPoliciesRequest) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BatchGetAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BatchGetAlertingPoliciesRequest) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if names := typedMsg.GetNames(); len(names) > 0 {
			return alerting_policy.AlertingPolicyNameList(names)
		}
	}
	return (alerting_policy.AlertingPolicyNameList)(nil)
}

func (h *BatchGetAlertingPoliciesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*BatchGetAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*BatchGetAlertingPoliciesRequest) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetAlertingPoliciesRequest) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetAlertingPoliciesRequest) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *BatchGetAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*BatchGetAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*BatchGetAlertingPoliciesResponse) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BatchGetAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BatchGetAlertingPoliciesResponse) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resources := typedMsg.GetAlertingPolicies(); len(resources) > 0 {
			list := make(alerting_policy.AlertingPolicyNameList, 0, len(resources))
			for _, res := range resources {
				list = append(list, res.GetName())
			}
			return list
		}
	}
	return (alerting_policy.AlertingPolicyNameList)(nil)
}

func (h *BatchGetAlertingPoliciesDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*BatchGetAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*BatchGetAlertingPoliciesResponse) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetAlertingPoliciesResponse) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetAlertingPoliciesResponse) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAlertingPolicies(); len(resources) > 0 {
			return alerting_policy.AlertingPolicyList(resources)
		}
	}
	return (alerting_policy.AlertingPolicyList)(nil)
}

func GetBatchGetAlertingPoliciesDescriptor() *BatchGetAlertingPoliciesDescriptor {
	return batchGetAlertingPoliciesDescriptor
}

type ListAlertingPoliciesDescriptor struct{}

type ListAlertingPoliciesDescriptorClientMsgHandle struct{}

type ListAlertingPoliciesDescriptorServerMsgHandle struct{}

func (d *ListAlertingPoliciesDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListAlertingPoliciesRequest{}
}

func (d *ListAlertingPoliciesDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListAlertingPoliciesResponse{}
}

func (d *ListAlertingPoliciesDescriptor) IsUnary() bool {
	return true
}

func (d *ListAlertingPoliciesDescriptor) IsClientStream() bool {
	return false
}

func (d *ListAlertingPoliciesDescriptor) IsServerStream() bool {
	return false
}

func (d *ListAlertingPoliciesDescriptor) IsCollection() bool {
	return true
}

func (d *ListAlertingPoliciesDescriptor) IsPlural() bool {
	return true
}

func (d *ListAlertingPoliciesDescriptor) HasResource() bool {
	return true
}

func (d *ListAlertingPoliciesDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *ListAlertingPoliciesDescriptor) GetVerb() string {
	return "list"
}

func (d *ListAlertingPoliciesDescriptor) GetMethodName() string {
	return "ListAlertingPolicies"
}

func (d *ListAlertingPoliciesDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService/ListAlertingPolicies"
}

func (d *ListAlertingPoliciesDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *ListAlertingPoliciesDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *ListAlertingPoliciesDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *ListAlertingPoliciesDescriptor) GetServiceVersion() string {
	return "v3"
}

func (d *ListAlertingPoliciesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingPolicyServiceDescriptor
}

func (d *ListAlertingPoliciesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_policy.GetDescriptor()
}

func (d *ListAlertingPoliciesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListAlertingPoliciesDescriptorClientMsgHandle{}
}

func (d *ListAlertingPoliciesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListAlertingPoliciesDescriptorServerMsgHandle{}
}

func (h *ListAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*ListAlertingPoliciesRequest) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *ListAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListAlertingPoliciesRequest) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListAlertingPoliciesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*ListAlertingPoliciesRequest) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if parentName := typedMsg.GetParent(); parentName != nil {
			return parentName
		}
	}
	return (*alerting_policy.ParentName)(nil)
}

func (h *ListAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListAlertingPoliciesRequest) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListAlertingPoliciesRequest) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *ListAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*ListAlertingPoliciesResponse) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *ListAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListAlertingPoliciesResponse) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resources := typedMsg.GetAlertingPolicies(); len(resources) > 0 {
			list := make(alerting_policy.AlertingPolicyNameList, 0, len(resources))
			for _, res := range resources {
				list = append(list, res.GetName())
			}
			return list
		}
	}
	return (alerting_policy.AlertingPolicyNameList)(nil)
}

func (h *ListAlertingPoliciesDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*ListAlertingPoliciesResponse) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *ListAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListAlertingPoliciesResponse) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListAlertingPoliciesResponse) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAlertingPolicies(); len(resources) > 0 {
			return alerting_policy.AlertingPolicyList(resources)
		}
	}
	return (alerting_policy.AlertingPolicyList)(nil)
}

func GetListAlertingPoliciesDescriptor() *ListAlertingPoliciesDescriptor {
	return listAlertingPoliciesDescriptor
}

type WatchAlertingPolicyDescriptor struct{}

type WatchAlertingPolicyDescriptorClientMsgHandle struct{}

type WatchAlertingPolicyDescriptorServerMsgHandle struct{}

func (d *WatchAlertingPolicyDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchAlertingPolicyRequest{}
}

func (d *WatchAlertingPolicyDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchAlertingPolicyResponse{}
}

func (d *WatchAlertingPolicyDescriptor) IsUnary() bool {
	return false
}

func (d *WatchAlertingPolicyDescriptor) IsClientStream() bool {
	return false
}

func (d *WatchAlertingPolicyDescriptor) IsServerStream() bool {
	return true
}

func (d *WatchAlertingPolicyDescriptor) IsCollection() bool {
	return false
}

func (d *WatchAlertingPolicyDescriptor) IsPlural() bool {
	return false
}

func (d *WatchAlertingPolicyDescriptor) HasResource() bool {
	return true
}

func (d *WatchAlertingPolicyDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *WatchAlertingPolicyDescriptor) GetVerb() string {
	return "watch"
}

func (d *WatchAlertingPolicyDescriptor) GetMethodName() string {
	return "WatchAlertingPolicy"
}

func (d *WatchAlertingPolicyDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService/WatchAlertingPolicy"
}

func (d *WatchAlertingPolicyDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *WatchAlertingPolicyDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *WatchAlertingPolicyDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *WatchAlertingPolicyDescriptor) GetServiceVersion() string {
	return "v3"
}

func (d *WatchAlertingPolicyDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingPolicyServiceDescriptor
}

func (d *WatchAlertingPolicyDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_policy.GetDescriptor()
}

func (d *WatchAlertingPolicyDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertingPolicyDescriptorClientMsgHandle{}
}

func (d *WatchAlertingPolicyDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertingPolicyDescriptorServerMsgHandle{}
}

func (h *WatchAlertingPolicyDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchAlertingPolicyRequest) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if name := typedMsg.GetName(); name != nil {
			return name
		}
	}
	return (*alerting_policy.Name)(nil)
}

func (h *WatchAlertingPolicyDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertingPolicyRequest) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchAlertingPolicyDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*WatchAlertingPolicyRequest) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *WatchAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertingPolicyRequest) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertingPolicyRequest) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchAlertingPolicyDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertingPolicyResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchAlertingPolicyResponse) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *alerting_policy.AlertingPolicyChange_Added_:
				return tResChange.Added.GetAlertingPolicy().GetName()
			case *alerting_policy.AlertingPolicyChange_Modified_:
				return tResChange.Modified.GetName()
			case *alerting_policy.AlertingPolicyChange_Removed_:
				return tResChange.Removed.GetName()
			case *alerting_policy.AlertingPolicyChange_Current_:
				return tResChange.Current.GetAlertingPolicy().GetName()
			}
		}
	}
	return (*alerting_policy.Name)(nil)
}

func (h *WatchAlertingPolicyDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertingPolicyResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertingPolicyResponse) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchAlertingPolicyDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertingPolicyResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*WatchAlertingPolicyResponse) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *WatchAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertingPolicyResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertingPolicyResponse) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *alerting_policy.AlertingPolicyChange_Added_:
				return tResChange.Added.GetAlertingPolicy()
			case *alerting_policy.AlertingPolicyChange_Modified_:
				return tResChange.Modified.GetAlertingPolicy()
			case *alerting_policy.AlertingPolicyChange_Current_:
				return tResChange.Current.GetAlertingPolicy()
			}
		}
	}
	return (*alerting_policy.AlertingPolicy)(nil)
}

func (h *WatchAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertingPolicyResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertingPolicyResponse) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchAlertingPolicyDescriptor() *WatchAlertingPolicyDescriptor {
	return watchAlertingPolicyDescriptor
}

type WatchAlertingPoliciesDescriptor struct{}

type WatchAlertingPoliciesDescriptorClientMsgHandle struct{}

type WatchAlertingPoliciesDescriptorServerMsgHandle struct{}

func (d *WatchAlertingPoliciesDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchAlertingPoliciesRequest{}
}

func (d *WatchAlertingPoliciesDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchAlertingPoliciesResponse{}
}

func (d *WatchAlertingPoliciesDescriptor) IsUnary() bool {
	return false
}

func (d *WatchAlertingPoliciesDescriptor) IsClientStream() bool {
	return false
}

func (d *WatchAlertingPoliciesDescriptor) IsServerStream() bool {
	return true
}

func (d *WatchAlertingPoliciesDescriptor) IsCollection() bool {
	return true
}

func (d *WatchAlertingPoliciesDescriptor) IsPlural() bool {
	return true
}

func (d *WatchAlertingPoliciesDescriptor) HasResource() bool {
	return true
}

func (d *WatchAlertingPoliciesDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *WatchAlertingPoliciesDescriptor) GetVerb() string {
	return "watch"
}

func (d *WatchAlertingPoliciesDescriptor) GetMethodName() string {
	return "WatchAlertingPolicies"
}

func (d *WatchAlertingPoliciesDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService/WatchAlertingPolicies"
}

func (d *WatchAlertingPoliciesDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *WatchAlertingPoliciesDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *WatchAlertingPoliciesDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *WatchAlertingPoliciesDescriptor) GetServiceVersion() string {
	return "v3"
}

func (d *WatchAlertingPoliciesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingPolicyServiceDescriptor
}

func (d *WatchAlertingPoliciesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_policy.GetDescriptor()
}

func (d *WatchAlertingPoliciesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertingPoliciesDescriptorClientMsgHandle{}
}

func (d *WatchAlertingPoliciesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertingPoliciesDescriptorServerMsgHandle{}
}

func (h *WatchAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchAlertingPoliciesRequest) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *WatchAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertingPoliciesRequest) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchAlertingPoliciesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*WatchAlertingPoliciesRequest) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if parentName := typedMsg.GetParent(); parentName != nil {
			return parentName
		}
	}
	return (*alerting_policy.ParentName)(nil)
}

func (h *WatchAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertingPoliciesRequest) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertingPoliciesRequest) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchAlertingPoliciesResponse) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *WatchAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertingPoliciesResponse) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetAlertingPolicyChanges(); len(resChanges) > 0 {
			list := make(alerting_policy.AlertingPolicyNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *alerting_policy.AlertingPolicyChange_Added_:
					list = append(list, tResChange.Added.GetAlertingPolicy().GetName())
				case *alerting_policy.AlertingPolicyChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *alerting_policy.AlertingPolicyChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *alerting_policy.AlertingPolicyChange_Current_:
					list = append(list, tResChange.Current.GetAlertingPolicy().GetName())
				}
			}
			return list
		}
	}
	return (alerting_policy.AlertingPolicyNameList)(nil)
}

func (h *WatchAlertingPoliciesDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*WatchAlertingPoliciesResponse) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *WatchAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertingPoliciesResponse) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertingPoliciesResponse) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetAlertingPolicyChanges(); len(resChanges) > 0 {
			list := make(alerting_policy.AlertingPolicyList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *alerting_policy.AlertingPolicyChange_Added_:
					list = append(list, tResChange.Added.GetAlertingPolicy())
				case *alerting_policy.AlertingPolicyChange_Modified_:
					list = append(list, tResChange.Modified.GetAlertingPolicy())
				case *alerting_policy.AlertingPolicyChange_Current_:
					list = append(list, tResChange.Current.GetAlertingPolicy())
				}
			}
			return list
		}
	}
	return (alerting_policy.AlertingPolicyList)(nil)
}

func GetWatchAlertingPoliciesDescriptor() *WatchAlertingPoliciesDescriptor {
	return watchAlertingPoliciesDescriptor
}

type CreateAlertingPolicyDescriptor struct{}

type CreateAlertingPolicyDescriptorClientMsgHandle struct{}

type CreateAlertingPolicyDescriptorServerMsgHandle struct{}

func (d *CreateAlertingPolicyDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateAlertingPolicyRequest{}
}

func (d *CreateAlertingPolicyDescriptor) NewEmptyServerMsg() proto.Message {
	return &alerting_policy.AlertingPolicy{}
}

func (d *CreateAlertingPolicyDescriptor) IsUnary() bool {
	return true
}

func (d *CreateAlertingPolicyDescriptor) IsClientStream() bool {
	return false
}

func (d *CreateAlertingPolicyDescriptor) IsServerStream() bool {
	return false
}

func (d *CreateAlertingPolicyDescriptor) IsCollection() bool {
	return true
}

func (d *CreateAlertingPolicyDescriptor) IsPlural() bool {
	return false
}

func (d *CreateAlertingPolicyDescriptor) HasResource() bool {
	return true
}

func (d *CreateAlertingPolicyDescriptor) RequestHasResourceBody() bool {
	return true
}

func (d *CreateAlertingPolicyDescriptor) GetVerb() string {
	return "create"
}

func (d *CreateAlertingPolicyDescriptor) GetMethodName() string {
	return "CreateAlertingPolicy"
}

func (d *CreateAlertingPolicyDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService/CreateAlertingPolicy"
}

func (d *CreateAlertingPolicyDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *CreateAlertingPolicyDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *CreateAlertingPolicyDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *CreateAlertingPolicyDescriptor) GetServiceVersion() string {
	return "v3"
}

func (d *CreateAlertingPolicyDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingPolicyServiceDescriptor
}

func (d *CreateAlertingPolicyDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_policy.GetDescriptor()
}

func (d *CreateAlertingPolicyDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateAlertingPolicyDescriptorClientMsgHandle{}
}

func (d *CreateAlertingPolicyDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateAlertingPolicyDescriptorServerMsgHandle{}
}

func (h *CreateAlertingPolicyDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*CreateAlertingPolicyRequest) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		res := typedMsg.GetAlertingPolicy()
		if name := res.GetName(); name != nil {
			return name
		}
	}
	return (*alerting_policy.Name)(nil)
}

func (h *CreateAlertingPolicyDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateAlertingPolicyRequest) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateAlertingPolicyDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*CreateAlertingPolicyRequest) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if parentName := typedMsg.GetParent(); parentName != nil {
			return parentName
		}
	}
	return (*alerting_policy.ParentName)(nil)
}

func (h *CreateAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateAlertingPolicyRequest) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetAlertingPolicy()
	}
	return (*alerting_policy.AlertingPolicy)(nil)
}

func (h *CreateAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateAlertingPolicyRequest) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *CreateAlertingPolicyDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*alerting_policy.AlertingPolicy) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if name := typedMsg.GetName(); name != nil {
			return name
		}
	}
	return (*alerting_policy.Name)(nil)
}

func (h *CreateAlertingPolicyDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*alerting_policy.AlertingPolicy) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateAlertingPolicyDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*alerting_policy.AlertingPolicy) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *CreateAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*alerting_policy.AlertingPolicy)
}

func (h *CreateAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*alerting_policy.AlertingPolicy) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateAlertingPolicyDescriptor() *CreateAlertingPolicyDescriptor {
	return createAlertingPolicyDescriptor
}

type UpdateAlertingPolicyDescriptor struct{}

type UpdateAlertingPolicyDescriptorClientMsgHandle struct{}

type UpdateAlertingPolicyDescriptorServerMsgHandle struct{}

func (d *UpdateAlertingPolicyDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateAlertingPolicyRequest{}
}

func (d *UpdateAlertingPolicyDescriptor) NewEmptyServerMsg() proto.Message {
	return &alerting_policy.AlertingPolicy{}
}

func (d *UpdateAlertingPolicyDescriptor) IsUnary() bool {
	return true
}

func (d *UpdateAlertingPolicyDescriptor) IsClientStream() bool {
	return false
}

func (d *UpdateAlertingPolicyDescriptor) IsServerStream() bool {
	return false
}

func (d *UpdateAlertingPolicyDescriptor) IsCollection() bool {
	return false
}

func (d *UpdateAlertingPolicyDescriptor) IsPlural() bool {
	return false
}

func (d *UpdateAlertingPolicyDescriptor) HasResource() bool {
	return true
}

func (d *UpdateAlertingPolicyDescriptor) RequestHasResourceBody() bool {
	return true
}

func (d *UpdateAlertingPolicyDescriptor) GetVerb() string {
	return "update"
}

func (d *UpdateAlertingPolicyDescriptor) GetMethodName() string {
	return "UpdateAlertingPolicy"
}

func (d *UpdateAlertingPolicyDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService/UpdateAlertingPolicy"
}

func (d *UpdateAlertingPolicyDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *UpdateAlertingPolicyDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *UpdateAlertingPolicyDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *UpdateAlertingPolicyDescriptor) GetServiceVersion() string {
	return "v3"
}

func (d *UpdateAlertingPolicyDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingPolicyServiceDescriptor
}

func (d *UpdateAlertingPolicyDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_policy.GetDescriptor()
}

func (d *UpdateAlertingPolicyDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateAlertingPolicyDescriptorClientMsgHandle{}
}

func (d *UpdateAlertingPolicyDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateAlertingPolicyDescriptorServerMsgHandle{}
}

func (h *UpdateAlertingPolicyDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*UpdateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*UpdateAlertingPolicyRequest) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		res := typedMsg.GetAlertingPolicy()
		if name := res.GetName(); name != nil {
			return name
		}
	}
	return (*alerting_policy.Name)(nil)
}

func (h *UpdateAlertingPolicyDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateAlertingPolicyRequest) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *UpdateAlertingPolicyDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*UpdateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*UpdateAlertingPolicyRequest) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *UpdateAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateAlertingPolicyRequest) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetAlertingPolicy()
	}
	return (*alerting_policy.AlertingPolicy)(nil)
}

func (h *UpdateAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateAlertingPolicyRequest) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *UpdateAlertingPolicyDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*alerting_policy.AlertingPolicy) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if name := typedMsg.GetName(); name != nil {
			return name
		}
	}
	return (*alerting_policy.Name)(nil)
}

func (h *UpdateAlertingPolicyDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*alerting_policy.AlertingPolicy) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *UpdateAlertingPolicyDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*alerting_policy.AlertingPolicy) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *UpdateAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*alerting_policy.AlertingPolicy)
}

func (h *UpdateAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*alerting_policy.AlertingPolicy)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*alerting_policy.AlertingPolicy) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateAlertingPolicyDescriptor() *UpdateAlertingPolicyDescriptor {
	return updateAlertingPolicyDescriptor
}

type DeleteAlertingPolicyDescriptor struct{}

type DeleteAlertingPolicyDescriptorClientMsgHandle struct{}

type DeleteAlertingPolicyDescriptorServerMsgHandle struct{}

func (d *DeleteAlertingPolicyDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteAlertingPolicyRequest{}
}

func (d *DeleteAlertingPolicyDescriptor) NewEmptyServerMsg() proto.Message {
	return &emptypb.Empty{}
}

func (d *DeleteAlertingPolicyDescriptor) IsUnary() bool {
	return true
}

func (d *DeleteAlertingPolicyDescriptor) IsClientStream() bool {
	return false
}

func (d *DeleteAlertingPolicyDescriptor) IsServerStream() bool {
	return false
}

func (d *DeleteAlertingPolicyDescriptor) IsCollection() bool {
	return false
}

func (d *DeleteAlertingPolicyDescriptor) IsPlural() bool {
	return false
}

func (d *DeleteAlertingPolicyDescriptor) HasResource() bool {
	return true
}

func (d *DeleteAlertingPolicyDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *DeleteAlertingPolicyDescriptor) GetVerb() string {
	return "delete"
}

func (d *DeleteAlertingPolicyDescriptor) GetMethodName() string {
	return "DeleteAlertingPolicy"
}

func (d *DeleteAlertingPolicyDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService/DeleteAlertingPolicy"
}

func (d *DeleteAlertingPolicyDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *DeleteAlertingPolicyDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *DeleteAlertingPolicyDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *DeleteAlertingPolicyDescriptor) GetServiceVersion() string {
	return "v3"
}

func (d *DeleteAlertingPolicyDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingPolicyServiceDescriptor
}

func (d *DeleteAlertingPolicyDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_policy.GetDescriptor()
}

func (d *DeleteAlertingPolicyDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteAlertingPolicyDescriptorClientMsgHandle{}
}

func (d *DeleteAlertingPolicyDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteAlertingPolicyDescriptorServerMsgHandle{}
}

func (h *DeleteAlertingPolicyDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*DeleteAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*DeleteAlertingPolicyRequest) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if name := typedMsg.GetName(); name != nil {
			return name
		}
	}
	return (*alerting_policy.Name)(nil)
}

func (h *DeleteAlertingPolicyDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteAlertingPolicyRequest) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *DeleteAlertingPolicyDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*DeleteAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*DeleteAlertingPolicyRequest) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *DeleteAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteAlertingPolicyRequest) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteAlertingPolicyDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteAlertingPolicyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteAlertingPolicyRequest) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *DeleteAlertingPolicyDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*emptypb.Empty) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *DeleteAlertingPolicyDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*emptypb.Empty) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *DeleteAlertingPolicyDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*emptypb.Empty) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *DeleteAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*emptypb.Empty) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteAlertingPolicyDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteAlertingPolicyDescriptor() *DeleteAlertingPolicyDescriptor {
	return deleteAlertingPolicyDescriptor
}

type SearchAlertingPoliciesDescriptor struct{}

type SearchAlertingPoliciesDescriptorClientMsgHandle struct{}

type SearchAlertingPoliciesDescriptorServerMsgHandle struct{}

func (d *SearchAlertingPoliciesDescriptor) NewEmptyClientMsg() proto.Message {
	return &SearchAlertingPoliciesRequest{}
}

func (d *SearchAlertingPoliciesDescriptor) NewEmptyServerMsg() proto.Message {
	return &SearchAlertingPoliciesResponse{}
}

func (d *SearchAlertingPoliciesDescriptor) IsUnary() bool {
	return true
}

func (d *SearchAlertingPoliciesDescriptor) IsClientStream() bool {
	return false
}

func (d *SearchAlertingPoliciesDescriptor) IsServerStream() bool {
	return false
}

func (d *SearchAlertingPoliciesDescriptor) IsCollection() bool {
	return true
}

func (d *SearchAlertingPoliciesDescriptor) IsPlural() bool {
	return true
}

func (d *SearchAlertingPoliciesDescriptor) HasResource() bool {
	return true
}

func (d *SearchAlertingPoliciesDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *SearchAlertingPoliciesDescriptor) GetVerb() string {
	return "search"
}

func (d *SearchAlertingPoliciesDescriptor) GetMethodName() string {
	return "SearchAlertingPolicies"
}

func (d *SearchAlertingPoliciesDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService/SearchAlertingPolicies"
}

func (d *SearchAlertingPoliciesDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *SearchAlertingPoliciesDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *SearchAlertingPoliciesDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *SearchAlertingPoliciesDescriptor) GetServiceVersion() string {
	return "v3"
}

func (d *SearchAlertingPoliciesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingPolicyServiceDescriptor
}

func (d *SearchAlertingPoliciesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_policy.GetDescriptor()
}

func (d *SearchAlertingPoliciesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchAlertingPoliciesDescriptorClientMsgHandle{}
}

func (d *SearchAlertingPoliciesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchAlertingPoliciesDescriptorServerMsgHandle{}
}

func (h *SearchAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*SearchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*SearchAlertingPoliciesRequest) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *SearchAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*SearchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*SearchAlertingPoliciesRequest) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *SearchAlertingPoliciesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*SearchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*SearchAlertingPoliciesRequest) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if parentName := typedMsg.GetParent(); parentName != nil {
			return parentName
		}
	}
	return (*alerting_policy.ParentName)(nil)
}

func (h *SearchAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SearchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SearchAlertingPoliciesRequest) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SearchAlertingPoliciesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SearchAlertingPoliciesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SearchAlertingPoliciesRequest) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *SearchAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*SearchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*SearchAlertingPoliciesResponse) *alerting_policy.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *SearchAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*SearchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*SearchAlertingPoliciesResponse) []*alerting_policy.Name
	})
	if ok {
		return alerting_policy.AlertingPolicyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resources := typedMsg.GetAlertingPolicies(); len(resources) > 0 {
			list := make(alerting_policy.AlertingPolicyNameList, 0, len(resources))
			for _, res := range resources {
				list = append(list, res.GetName())
			}
			return list
		}
	}
	return (alerting_policy.AlertingPolicyNameList)(nil)
}

func (h *SearchAlertingPoliciesDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*SearchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*SearchAlertingPoliciesResponse) *alerting_policy.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *SearchAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SearchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SearchAlertingPoliciesResponse) *alerting_policy.AlertingPolicy
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SearchAlertingPoliciesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SearchAlertingPoliciesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SearchAlertingPoliciesResponse) []*alerting_policy.AlertingPolicy
	})
	if ok {
		return alerting_policy.AlertingPolicyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAlertingPolicies(); len(resources) > 0 {
			return alerting_policy.AlertingPolicyList(resources)
		}
	}
	return (alerting_policy.AlertingPolicyList)(nil)
}

func GetSearchAlertingPoliciesDescriptor() *SearchAlertingPoliciesDescriptor {
	return searchAlertingPoliciesDescriptor
}

type AlertingPolicyServiceDescriptor struct{}

func (d *AlertingPolicyServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getAlertingPolicyDescriptor,
		batchGetAlertingPoliciesDescriptor,
		listAlertingPoliciesDescriptor,
		watchAlertingPolicyDescriptor,
		watchAlertingPoliciesDescriptor,
		createAlertingPolicyDescriptor,
		updateAlertingPolicyDescriptor,
		deleteAlertingPolicyDescriptor,
		searchAlertingPoliciesDescriptor,
	}
}

func (d *AlertingPolicyServiceDescriptor) GetFullAPIName() string {
	return "/ntt.monitoring.v3.AlertingPolicyService"
}

func (d *AlertingPolicyServiceDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v3"
}

func (d *AlertingPolicyServiceDescriptor) GetApiName() string {
	return "AlertingPolicyService"
}

func (d *AlertingPolicyServiceDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *AlertingPolicyServiceDescriptor) GetServiceVersion() string {
	return "v3"
}

func GetAlertingPolicyServiceDescriptor() *AlertingPolicyServiceDescriptor {
	return alertingPolicyServiceDescriptor
}

func initDescriptors() {
	alertingPolicyServiceDescriptor = &AlertingPolicyServiceDescriptor{}
	getAlertingPolicyDescriptor = &GetAlertingPolicyDescriptor{}
	batchGetAlertingPoliciesDescriptor = &BatchGetAlertingPoliciesDescriptor{}
	listAlertingPoliciesDescriptor = &ListAlertingPoliciesDescriptor{}
	watchAlertingPolicyDescriptor = &WatchAlertingPolicyDescriptor{}
	watchAlertingPoliciesDescriptor = &WatchAlertingPoliciesDescriptor{}
	createAlertingPolicyDescriptor = &CreateAlertingPolicyDescriptor{}
	updateAlertingPolicyDescriptor = &UpdateAlertingPolicyDescriptor{}
	deleteAlertingPolicyDescriptor = &DeleteAlertingPolicyDescriptor{}
	searchAlertingPoliciesDescriptor = &SearchAlertingPoliciesDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(alertingPolicyServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getAlertingPolicyDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetAlertingPoliciesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listAlertingPoliciesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchAlertingPolicyDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchAlertingPoliciesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createAlertingPolicyDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateAlertingPolicyDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteAlertingPolicyDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(searchAlertingPoliciesDescriptor)
}

func init() {
	if !descriptorsInitialized {
		initDescriptors()
		descriptorsInitialized = true
	}
}