alerting_condition_service.pb.descriptors.go

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

package alerting_condition_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_condition "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/alerting_condition"
	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_condition.AlertingCondition{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized               bool
	alertingConditionServiceDescriptor   *AlertingConditionServiceDescriptor
	getAlertingConditionDescriptor       *GetAlertingConditionDescriptor
	batchGetAlertingConditionsDescriptor *BatchGetAlertingConditionsDescriptor
	listAlertingConditionsDescriptor     *ListAlertingConditionsDescriptor
	watchAlertingConditionDescriptor     *WatchAlertingConditionDescriptor
	watchAlertingConditionsDescriptor    *WatchAlertingConditionsDescriptor
	createAlertingConditionDescriptor    *CreateAlertingConditionDescriptor
	updateAlertingConditionDescriptor    *UpdateAlertingConditionDescriptor
	deleteAlertingConditionDescriptor    *DeleteAlertingConditionDescriptor
	searchAlertingConditionsDescriptor   *SearchAlertingConditionsDescriptor
)

type GetAlertingConditionDescriptor struct{}

type GetAlertingConditionDescriptorClientMsgHandle struct{}

type GetAlertingConditionDescriptorServerMsgHandle struct{}

func (d *GetAlertingConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetAlertingConditionRequest{}
}

func (d *GetAlertingConditionDescriptor) NewEmptyServerMsg() proto.Message {
	return &alerting_condition.AlertingCondition{}
}

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

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

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

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

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

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

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

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

func (d *GetAlertingConditionDescriptor) GetMethodName() string {
	return "GetAlertingCondition"
}

func (d *GetAlertingConditionDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertingConditionService/GetAlertingCondition"
}

func (d *GetAlertingConditionDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *GetAlertingConditionDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *GetAlertingConditionDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *GetAlertingConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingConditionServiceDescriptor
}

func (d *GetAlertingConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_condition.GetDescriptor()
}

func (d *GetAlertingConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetAlertingConditionDescriptorClientMsgHandle{}
}

func (d *GetAlertingConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetAlertingConditionDescriptorServerMsgHandle{}
}

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

func (h *GetAlertingConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetAlertingConditionRequest) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetAlertingConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetAlertingConditionRequest) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetAlertingConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetAlertingConditionRequest) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetAlertingConditionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*alerting_condition.AlertingCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*alerting_condition.AlertingCondition) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetAlertingConditionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*alerting_condition.AlertingCondition)
}

func (h *GetAlertingConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*alerting_condition.AlertingCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*alerting_condition.AlertingCondition) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetAlertingConditionDescriptor() *GetAlertingConditionDescriptor {
	return getAlertingConditionDescriptor
}

type BatchGetAlertingConditionsDescriptor struct{}

type BatchGetAlertingConditionsDescriptorClientMsgHandle struct{}

type BatchGetAlertingConditionsDescriptorServerMsgHandle struct{}

func (d *BatchGetAlertingConditionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetAlertingConditionsRequest{}
}

func (d *BatchGetAlertingConditionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetAlertingConditionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetAlertingConditionsDescriptor) GetMethodName() string {
	return "BatchGetAlertingConditions"
}

func (d *BatchGetAlertingConditionsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertingConditionService/BatchGetAlertingConditions"
}

func (d *BatchGetAlertingConditionsDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *BatchGetAlertingConditionsDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *BatchGetAlertingConditionsDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *BatchGetAlertingConditionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingConditionServiceDescriptor
}

func (d *BatchGetAlertingConditionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_condition.GetDescriptor()
}

func (d *BatchGetAlertingConditionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetAlertingConditionsDescriptorClientMsgHandle{}
}

func (d *BatchGetAlertingConditionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetAlertingConditionsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetAlertingConditionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetAlertingConditionsRequest) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertingConditionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetAlertingConditionsRequest) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetAlertingConditionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetAlertingConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetAlertingConditionsResponse) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertingConditionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetAlertingConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetAlertingConditionsResponse) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAlertingConditions(); len(resources) > 0 {
			return alerting_condition.AlertingConditionList(resources)
		}
	}
	return (alerting_condition.AlertingConditionList)(nil)
}

func GetBatchGetAlertingConditionsDescriptor() *BatchGetAlertingConditionsDescriptor {
	return batchGetAlertingConditionsDescriptor
}

type ListAlertingConditionsDescriptor struct{}

type ListAlertingConditionsDescriptorClientMsgHandle struct{}

type ListAlertingConditionsDescriptorServerMsgHandle struct{}

func (d *ListAlertingConditionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListAlertingConditionsRequest{}
}

func (d *ListAlertingConditionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListAlertingConditionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListAlertingConditionsDescriptor) GetMethodName() string {
	return "ListAlertingConditions"
}

func (d *ListAlertingConditionsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertingConditionService/ListAlertingConditions"
}

func (d *ListAlertingConditionsDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *ListAlertingConditionsDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *ListAlertingConditionsDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *ListAlertingConditionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingConditionServiceDescriptor
}

func (d *ListAlertingConditionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_condition.GetDescriptor()
}

func (d *ListAlertingConditionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListAlertingConditionsDescriptorClientMsgHandle{}
}

func (d *ListAlertingConditionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListAlertingConditionsDescriptorServerMsgHandle{}
}

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

func (h *ListAlertingConditionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListAlertingConditionsRequest) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListAlertingConditionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListAlertingConditionsRequest) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListAlertingConditionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListAlertingConditionsRequest) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListAlertingConditionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListAlertingConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListAlertingConditionsResponse) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListAlertingConditionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListAlertingConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListAlertingConditionsResponse) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAlertingConditions(); len(resources) > 0 {
			return alerting_condition.AlertingConditionList(resources)
		}
	}
	return (alerting_condition.AlertingConditionList)(nil)
}

func GetListAlertingConditionsDescriptor() *ListAlertingConditionsDescriptor {
	return listAlertingConditionsDescriptor
}

type WatchAlertingConditionDescriptor struct{}

type WatchAlertingConditionDescriptorClientMsgHandle struct{}

type WatchAlertingConditionDescriptorServerMsgHandle struct{}

func (d *WatchAlertingConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchAlertingConditionRequest{}
}

func (d *WatchAlertingConditionDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchAlertingConditionResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchAlertingConditionDescriptor) GetMethodName() string {
	return "WatchAlertingCondition"
}

func (d *WatchAlertingConditionDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertingConditionService/WatchAlertingCondition"
}

func (d *WatchAlertingConditionDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *WatchAlertingConditionDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *WatchAlertingConditionDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *WatchAlertingConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingConditionServiceDescriptor
}

func (d *WatchAlertingConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_condition.GetDescriptor()
}

func (d *WatchAlertingConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertingConditionDescriptorClientMsgHandle{}
}

func (d *WatchAlertingConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertingConditionDescriptorServerMsgHandle{}
}

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

func (h *WatchAlertingConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertingConditionRequest) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchAlertingConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertingConditionRequest) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAlertingConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertingConditionRequest) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchAlertingConditionDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertingConditionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchAlertingConditionResponse) *alerting_condition.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *alerting_condition.AlertingConditionChange_Added_:
				return tResChange.Added.GetAlertingCondition().GetName()
			case *alerting_condition.AlertingConditionChange_Modified_:
				return tResChange.Modified.GetName()
			case *alerting_condition.AlertingConditionChange_Removed_:
				return tResChange.Removed.GetName()
			case *alerting_condition.AlertingConditionChange_Current_:
				return tResChange.Current.GetAlertingCondition().GetName()
			}
		}
	}
	return (*alerting_condition.Name)(nil)
}

func (h *WatchAlertingConditionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertingConditionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertingConditionResponse) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchAlertingConditionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertingConditionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertingConditionResponse) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *alerting_condition.AlertingConditionChange_Added_:
				return tResChange.Added.GetAlertingCondition()
			case *alerting_condition.AlertingConditionChange_Modified_:
				return tResChange.Modified.GetAlertingCondition()
			case *alerting_condition.AlertingConditionChange_Current_:
				return tResChange.Current.GetAlertingCondition()
			}
		}
	}
	return (*alerting_condition.AlertingCondition)(nil)
}

func (h *WatchAlertingConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertingConditionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertingConditionResponse) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchAlertingConditionDescriptor() *WatchAlertingConditionDescriptor {
	return watchAlertingConditionDescriptor
}

type WatchAlertingConditionsDescriptor struct{}

type WatchAlertingConditionsDescriptorClientMsgHandle struct{}

type WatchAlertingConditionsDescriptorServerMsgHandle struct{}

func (d *WatchAlertingConditionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchAlertingConditionsRequest{}
}

func (d *WatchAlertingConditionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchAlertingConditionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchAlertingConditionsDescriptor) GetMethodName() string {
	return "WatchAlertingConditions"
}

func (d *WatchAlertingConditionsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertingConditionService/WatchAlertingConditions"
}

func (d *WatchAlertingConditionsDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *WatchAlertingConditionsDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *WatchAlertingConditionsDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *WatchAlertingConditionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingConditionServiceDescriptor
}

func (d *WatchAlertingConditionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_condition.GetDescriptor()
}

func (d *WatchAlertingConditionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertingConditionsDescriptorClientMsgHandle{}
}

func (d *WatchAlertingConditionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertingConditionsDescriptorServerMsgHandle{}
}

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

func (h *WatchAlertingConditionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertingConditionsRequest) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchAlertingConditionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertingConditionsRequest) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAlertingConditionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertingConditionsRequest) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchAlertingConditionsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertingConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertingConditionsResponse) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetAlertingConditionChanges(); len(resChanges) > 0 {
			list := make(alerting_condition.AlertingConditionNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *alerting_condition.AlertingConditionChange_Added_:
					list = append(list, tResChange.Added.GetAlertingCondition().GetName())
				case *alerting_condition.AlertingConditionChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *alerting_condition.AlertingConditionChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *alerting_condition.AlertingConditionChange_Current_:
					list = append(list, tResChange.Current.GetAlertingCondition().GetName())
				}
			}
			return list
		}
	}
	return (alerting_condition.AlertingConditionNameList)(nil)
}

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

func (h *WatchAlertingConditionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertingConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertingConditionsResponse) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAlertingConditionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertingConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertingConditionsResponse) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetAlertingConditionChanges(); len(resChanges) > 0 {
			list := make(alerting_condition.AlertingConditionList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *alerting_condition.AlertingConditionChange_Added_:
					list = append(list, tResChange.Added.GetAlertingCondition())
				case *alerting_condition.AlertingConditionChange_Modified_:
					list = append(list, tResChange.Modified.GetAlertingCondition())
				case *alerting_condition.AlertingConditionChange_Current_:
					list = append(list, tResChange.Current.GetAlertingCondition())
				}
			}
			return list
		}
	}
	return (alerting_condition.AlertingConditionList)(nil)
}

func GetWatchAlertingConditionsDescriptor() *WatchAlertingConditionsDescriptor {
	return watchAlertingConditionsDescriptor
}

type CreateAlertingConditionDescriptor struct{}

type CreateAlertingConditionDescriptorClientMsgHandle struct{}

type CreateAlertingConditionDescriptorServerMsgHandle struct{}

func (d *CreateAlertingConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateAlertingConditionRequest{}
}

func (d *CreateAlertingConditionDescriptor) NewEmptyServerMsg() proto.Message {
	return &alerting_condition.AlertingCondition{}
}

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

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

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

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

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

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

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

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

func (d *CreateAlertingConditionDescriptor) GetMethodName() string {
	return "CreateAlertingCondition"
}

func (d *CreateAlertingConditionDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertingConditionService/CreateAlertingCondition"
}

func (d *CreateAlertingConditionDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *CreateAlertingConditionDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *CreateAlertingConditionDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *CreateAlertingConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingConditionServiceDescriptor
}

func (d *CreateAlertingConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_condition.GetDescriptor()
}

func (d *CreateAlertingConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateAlertingConditionDescriptorClientMsgHandle{}
}

func (d *CreateAlertingConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateAlertingConditionDescriptorServerMsgHandle{}
}

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

func (h *CreateAlertingConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateAlertingConditionRequest) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateAlertingConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateAlertingConditionRequest) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetAlertingCondition()
	}
	return (*alerting_condition.AlertingCondition)(nil)
}

func (h *CreateAlertingConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateAlertingConditionRequest) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateAlertingConditionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*alerting_condition.AlertingCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*alerting_condition.AlertingCondition) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateAlertingConditionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*alerting_condition.AlertingCondition)
}

func (h *CreateAlertingConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*alerting_condition.AlertingCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*alerting_condition.AlertingCondition) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateAlertingConditionDescriptor() *CreateAlertingConditionDescriptor {
	return createAlertingConditionDescriptor
}

type UpdateAlertingConditionDescriptor struct{}

type UpdateAlertingConditionDescriptorClientMsgHandle struct{}

type UpdateAlertingConditionDescriptorServerMsgHandle struct{}

func (d *UpdateAlertingConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateAlertingConditionRequest{}
}

func (d *UpdateAlertingConditionDescriptor) NewEmptyServerMsg() proto.Message {
	return &alerting_condition.AlertingCondition{}
}

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

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

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

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

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

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

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

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

func (d *UpdateAlertingConditionDescriptor) GetMethodName() string {
	return "UpdateAlertingCondition"
}

func (d *UpdateAlertingConditionDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertingConditionService/UpdateAlertingCondition"
}

func (d *UpdateAlertingConditionDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *UpdateAlertingConditionDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *UpdateAlertingConditionDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *UpdateAlertingConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingConditionServiceDescriptor
}

func (d *UpdateAlertingConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_condition.GetDescriptor()
}

func (d *UpdateAlertingConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateAlertingConditionDescriptorClientMsgHandle{}
}

func (d *UpdateAlertingConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateAlertingConditionDescriptorServerMsgHandle{}
}

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

func (h *UpdateAlertingConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateAlertingConditionRequest) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateAlertingConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateAlertingConditionRequest) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetAlertingCondition()
	}
	return (*alerting_condition.AlertingCondition)(nil)
}

func (h *UpdateAlertingConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateAlertingConditionRequest) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateAlertingConditionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*alerting_condition.AlertingCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*alerting_condition.AlertingCondition) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateAlertingConditionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*alerting_condition.AlertingCondition)
}

func (h *UpdateAlertingConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*alerting_condition.AlertingCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*alerting_condition.AlertingCondition) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateAlertingConditionDescriptor() *UpdateAlertingConditionDescriptor {
	return updateAlertingConditionDescriptor
}

type DeleteAlertingConditionDescriptor struct{}

type DeleteAlertingConditionDescriptorClientMsgHandle struct{}

type DeleteAlertingConditionDescriptorServerMsgHandle struct{}

func (d *DeleteAlertingConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteAlertingConditionRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteAlertingConditionDescriptor) GetMethodName() string {
	return "DeleteAlertingCondition"
}

func (d *DeleteAlertingConditionDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertingConditionService/DeleteAlertingCondition"
}

func (d *DeleteAlertingConditionDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *DeleteAlertingConditionDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *DeleteAlertingConditionDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *DeleteAlertingConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingConditionServiceDescriptor
}

func (d *DeleteAlertingConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_condition.GetDescriptor()
}

func (d *DeleteAlertingConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteAlertingConditionDescriptorClientMsgHandle{}
}

func (d *DeleteAlertingConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteAlertingConditionDescriptorServerMsgHandle{}
}

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

func (h *DeleteAlertingConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteAlertingConditionRequest) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteAlertingConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteAlertingConditionRequest) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteAlertingConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteAlertingConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteAlertingConditionRequest) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteAlertingConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteAlertingConditionDescriptor() *DeleteAlertingConditionDescriptor {
	return deleteAlertingConditionDescriptor
}

type SearchAlertingConditionsDescriptor struct{}

type SearchAlertingConditionsDescriptorClientMsgHandle struct{}

type SearchAlertingConditionsDescriptorServerMsgHandle struct{}

func (d *SearchAlertingConditionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &SearchAlertingConditionsRequest{}
}

func (d *SearchAlertingConditionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &SearchAlertingConditionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *SearchAlertingConditionsDescriptor) GetMethodName() string {
	return "SearchAlertingConditions"
}

func (d *SearchAlertingConditionsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertingConditionService/SearchAlertingConditions"
}

func (d *SearchAlertingConditionsDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *SearchAlertingConditionsDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *SearchAlertingConditionsDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *SearchAlertingConditionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertingConditionServiceDescriptor
}

func (d *SearchAlertingConditionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alerting_condition.GetDescriptor()
}

func (d *SearchAlertingConditionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchAlertingConditionsDescriptorClientMsgHandle{}
}

func (d *SearchAlertingConditionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchAlertingConditionsDescriptorServerMsgHandle{}
}

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

func (h *SearchAlertingConditionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*SearchAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*SearchAlertingConditionsRequest) []*alerting_condition.Name
	})
	if ok {
		return alerting_condition.AlertingConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *SearchAlertingConditionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SearchAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SearchAlertingConditionsRequest) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SearchAlertingConditionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SearchAlertingConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SearchAlertingConditionsRequest) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *SearchAlertingConditionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SearchAlertingConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SearchAlertingConditionsResponse) *alerting_condition.AlertingCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SearchAlertingConditionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SearchAlertingConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SearchAlertingConditionsResponse) []*alerting_condition.AlertingCondition
	})
	if ok {
		return alerting_condition.AlertingConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAlertingConditions(); len(resources) > 0 {
			return alerting_condition.AlertingConditionList(resources)
		}
	}
	return (alerting_condition.AlertingConditionList)(nil)
}

func GetSearchAlertingConditionsDescriptor() *SearchAlertingConditionsDescriptor {
	return searchAlertingConditionsDescriptor
}

type AlertingConditionServiceDescriptor struct{}

func (d *AlertingConditionServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getAlertingConditionDescriptor,
		batchGetAlertingConditionsDescriptor,
		listAlertingConditionsDescriptor,
		watchAlertingConditionDescriptor,
		watchAlertingConditionsDescriptor,
		createAlertingConditionDescriptor,
		updateAlertingConditionDescriptor,
		deleteAlertingConditionDescriptor,
		searchAlertingConditionsDescriptor,
	}
}

func (d *AlertingConditionServiceDescriptor) GetFullAPIName() string {
	return "/ntt.monitoring.v4.AlertingConditionService"
}

func (d *AlertingConditionServiceDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *AlertingConditionServiceDescriptor) GetApiName() string {
	return "AlertingConditionService"
}

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

func (d *AlertingConditionServiceDescriptor) GetServiceVersion() string {
	return "v4"
}

func GetAlertingConditionServiceDescriptor() *AlertingConditionServiceDescriptor {
	return alertingConditionServiceDescriptor
}

func initDescriptors() {
	alertingConditionServiceDescriptor = &AlertingConditionServiceDescriptor{}
	getAlertingConditionDescriptor = &GetAlertingConditionDescriptor{}
	batchGetAlertingConditionsDescriptor = &BatchGetAlertingConditionsDescriptor{}
	listAlertingConditionsDescriptor = &ListAlertingConditionsDescriptor{}
	watchAlertingConditionDescriptor = &WatchAlertingConditionDescriptor{}
	watchAlertingConditionsDescriptor = &WatchAlertingConditionsDescriptor{}
	createAlertingConditionDescriptor = &CreateAlertingConditionDescriptor{}
	updateAlertingConditionDescriptor = &UpdateAlertingConditionDescriptor{}
	deleteAlertingConditionDescriptor = &DeleteAlertingConditionDescriptor{}
	searchAlertingConditionsDescriptor = &SearchAlertingConditionsDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(alertingConditionServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getAlertingConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetAlertingConditionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listAlertingConditionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchAlertingConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchAlertingConditionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createAlertingConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateAlertingConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteAlertingConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(searchAlertingConditionsDescriptor)
}

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