github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/client/v4/alert/alert_service.pb.descriptors.go

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

package alert_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 (
	alert "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/alert"
	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 (
	_ = &alert.Alert{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized     bool
	alertServiceDescriptor     *AlertServiceDescriptor
	getAlertDescriptor         *GetAlertDescriptor
	batchGetAlertsDescriptor   *BatchGetAlertsDescriptor
	listAlertsDescriptor       *ListAlertsDescriptor
	watchAlertDescriptor       *WatchAlertDescriptor
	watchAlertsDescriptor      *WatchAlertsDescriptor
	updateAlertDescriptor      *UpdateAlertDescriptor
	deleteAlertDescriptor      *DeleteAlertDescriptor
	bulkCreateAlertsDescriptor *BulkCreateAlertsDescriptor
	bulkUpdateAlertsDescriptor *BulkUpdateAlertsDescriptor
)

type GetAlertDescriptor struct{}

type GetAlertDescriptorClientMsgHandle struct{}

type GetAlertDescriptorServerMsgHandle struct{}

func (d *GetAlertDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetAlertRequest{}
}

func (d *GetAlertDescriptor) NewEmptyServerMsg() proto.Message {
	return &alert.Alert{}
}

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

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

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

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

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

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

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

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

func (d *GetAlertDescriptor) GetMethodName() string {
	return "GetAlert"
}

func (d *GetAlertDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertService/GetAlert"
}

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

func (d *GetAlertDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func (d *GetAlertDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertServiceDescriptor
}

func (d *GetAlertDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alert.GetDescriptor()
}

func (d *GetAlertDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetAlertDescriptorClientMsgHandle{}
}

func (d *GetAlertDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetAlertDescriptorServerMsgHandle{}
}

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

func (h *GetAlertDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetAlertRequest) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetAlertDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetAlertRequest) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetAlertDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetAlertRequest) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetAlertDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*alert.Alert)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*alert.Alert) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetAlertDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*alert.Alert)
}

func (h *GetAlertDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*alert.Alert)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*alert.Alert) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetAlertDescriptor() *GetAlertDescriptor {
	return getAlertDescriptor
}

type BatchGetAlertsDescriptor struct{}

type BatchGetAlertsDescriptorClientMsgHandle struct{}

type BatchGetAlertsDescriptorServerMsgHandle struct{}

func (d *BatchGetAlertsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetAlertsRequest{}
}

func (d *BatchGetAlertsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetAlertsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetAlertsDescriptor) GetMethodName() string {
	return "BatchGetAlerts"
}

func (d *BatchGetAlertsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertService/BatchGetAlerts"
}

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

func (d *BatchGetAlertsDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func (d *BatchGetAlertsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertServiceDescriptor
}

func (d *BatchGetAlertsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alert.GetDescriptor()
}

func (d *BatchGetAlertsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetAlertsDescriptorClientMsgHandle{}
}

func (d *BatchGetAlertsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetAlertsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetAlertsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetAlertsRequest) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetAlertsRequest) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetAlertsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetAlertsResponse) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetAlertsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetAlertsResponse) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAlerts(); len(resources) > 0 {
			return alert.AlertList(resources)
		}
	}
	return (alert.AlertList)(nil)
}

func GetBatchGetAlertsDescriptor() *BatchGetAlertsDescriptor {
	return batchGetAlertsDescriptor
}

type ListAlertsDescriptor struct{}

type ListAlertsDescriptorClientMsgHandle struct{}

type ListAlertsDescriptorServerMsgHandle struct{}

func (d *ListAlertsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListAlertsRequest{}
}

func (d *ListAlertsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListAlertsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListAlertsDescriptor) GetMethodName() string {
	return "ListAlerts"
}

func (d *ListAlertsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertService/ListAlerts"
}

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

func (d *ListAlertsDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func (d *ListAlertsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertServiceDescriptor
}

func (d *ListAlertsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alert.GetDescriptor()
}

func (d *ListAlertsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListAlertsDescriptorClientMsgHandle{}
}

func (d *ListAlertsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListAlertsDescriptorServerMsgHandle{}
}

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

func (h *ListAlertsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListAlertsRequest) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListAlertsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListAlertsRequest) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListAlertsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListAlertsRequest) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListAlertsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListAlertsResponse) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListAlertsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListAlertsResponse) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAlerts(); len(resources) > 0 {
			return alert.AlertList(resources)
		}
	}
	return (alert.AlertList)(nil)
}

func GetListAlertsDescriptor() *ListAlertsDescriptor {
	return listAlertsDescriptor
}

type WatchAlertDescriptor struct{}

type WatchAlertDescriptorClientMsgHandle struct{}

type WatchAlertDescriptorServerMsgHandle struct{}

func (d *WatchAlertDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchAlertRequest{}
}

func (d *WatchAlertDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchAlertResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchAlertDescriptor) GetMethodName() string {
	return "WatchAlert"
}

func (d *WatchAlertDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertService/WatchAlert"
}

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

func (d *WatchAlertDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func (d *WatchAlertDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertServiceDescriptor
}

func (d *WatchAlertDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alert.GetDescriptor()
}

func (d *WatchAlertDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertDescriptorClientMsgHandle{}
}

func (d *WatchAlertDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertDescriptorServerMsgHandle{}
}

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

func (h *WatchAlertDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertRequest) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchAlertDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertRequest) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAlertDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertRequest) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchAlertDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAlertResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchAlertResponse) *alert.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *alert.AlertChange_Added_:
				return tResChange.Added.GetAlert().GetName()
			case *alert.AlertChange_Modified_:
				return tResChange.Modified.GetName()
			case *alert.AlertChange_Removed_:
				return tResChange.Removed.GetName()
			case *alert.AlertChange_Current_:
				return tResChange.Current.GetAlert().GetName()
			}
		}
	}
	return (*alert.Name)(nil)
}

func (h *WatchAlertDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertResponse) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchAlertDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertResponse) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *alert.AlertChange_Added_:
				return tResChange.Added.GetAlert()
			case *alert.AlertChange_Modified_:
				return tResChange.Modified.GetAlert()
			case *alert.AlertChange_Current_:
				return tResChange.Current.GetAlert()
			}
		}
	}
	return (*alert.Alert)(nil)
}

func (h *WatchAlertDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertResponse) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchAlertDescriptor() *WatchAlertDescriptor {
	return watchAlertDescriptor
}

type WatchAlertsDescriptor struct{}

type WatchAlertsDescriptorClientMsgHandle struct{}

type WatchAlertsDescriptorServerMsgHandle struct{}

func (d *WatchAlertsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchAlertsRequest{}
}

func (d *WatchAlertsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchAlertsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchAlertsDescriptor) GetMethodName() string {
	return "WatchAlerts"
}

func (d *WatchAlertsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertService/WatchAlerts"
}

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

func (d *WatchAlertsDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func (d *WatchAlertsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertServiceDescriptor
}

func (d *WatchAlertsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alert.GetDescriptor()
}

func (d *WatchAlertsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertsDescriptorClientMsgHandle{}
}

func (d *WatchAlertsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAlertsDescriptorServerMsgHandle{}
}

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

func (h *WatchAlertsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertsRequest) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchAlertsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertsRequest) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAlertsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertsRequest) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchAlertsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAlertsResponse) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetAlertChanges(); len(resChanges) > 0 {
			list := make(alert.AlertNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *alert.AlertChange_Added_:
					list = append(list, tResChange.Added.GetAlert().GetName())
				case *alert.AlertChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *alert.AlertChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *alert.AlertChange_Current_:
					list = append(list, tResChange.Current.GetAlert().GetName())
				}
			}
			return list
		}
	}
	return (alert.AlertNameList)(nil)
}

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

func (h *WatchAlertsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAlertsResponse) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAlertsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAlertsResponse) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetAlertChanges(); len(resChanges) > 0 {
			list := make(alert.AlertList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *alert.AlertChange_Added_:
					list = append(list, tResChange.Added.GetAlert())
				case *alert.AlertChange_Modified_:
					list = append(list, tResChange.Modified.GetAlert())
				case *alert.AlertChange_Current_:
					list = append(list, tResChange.Current.GetAlert())
				}
			}
			return list
		}
	}
	return (alert.AlertList)(nil)
}

func GetWatchAlertsDescriptor() *WatchAlertsDescriptor {
	return watchAlertsDescriptor
}

type UpdateAlertDescriptor struct{}

type UpdateAlertDescriptorClientMsgHandle struct{}

type UpdateAlertDescriptorServerMsgHandle struct{}

func (d *UpdateAlertDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateAlertRequest{}
}

func (d *UpdateAlertDescriptor) NewEmptyServerMsg() proto.Message {
	return &alert.Alert{}
}

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

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

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

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

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

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

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

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

func (d *UpdateAlertDescriptor) GetMethodName() string {
	return "UpdateAlert"
}

func (d *UpdateAlertDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertService/UpdateAlert"
}

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

func (d *UpdateAlertDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func (d *UpdateAlertDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertServiceDescriptor
}

func (d *UpdateAlertDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alert.GetDescriptor()
}

func (d *UpdateAlertDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateAlertDescriptorClientMsgHandle{}
}

func (d *UpdateAlertDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateAlertDescriptorServerMsgHandle{}
}

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

func (h *UpdateAlertDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateAlertRequest) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateAlertDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateAlertRequest) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetAlert()
	}
	return (*alert.Alert)(nil)
}

func (h *UpdateAlertDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateAlertRequest) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateAlertDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*alert.Alert)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*alert.Alert) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateAlertDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*alert.Alert)
}

func (h *UpdateAlertDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*alert.Alert)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*alert.Alert) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateAlertDescriptor() *UpdateAlertDescriptor {
	return updateAlertDescriptor
}

type DeleteAlertDescriptor struct{}

type DeleteAlertDescriptorClientMsgHandle struct{}

type DeleteAlertDescriptorServerMsgHandle struct{}

func (d *DeleteAlertDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteAlertRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteAlertDescriptor) GetMethodName() string {
	return "DeleteAlert"
}

func (d *DeleteAlertDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertService/DeleteAlert"
}

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

func (d *DeleteAlertDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func (d *DeleteAlertDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertServiceDescriptor
}

func (d *DeleteAlertDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alert.GetDescriptor()
}

func (d *DeleteAlertDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteAlertDescriptorClientMsgHandle{}
}

func (d *DeleteAlertDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteAlertDescriptorServerMsgHandle{}
}

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

func (h *DeleteAlertDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteAlertRequest) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteAlertDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteAlertRequest) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteAlertDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteAlertRequest) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteAlertDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteAlertDescriptor() *DeleteAlertDescriptor {
	return deleteAlertDescriptor
}

type BulkCreateAlertsDescriptor struct{}

type BulkCreateAlertsDescriptorClientMsgHandle struct{}

type BulkCreateAlertsDescriptorServerMsgHandle struct{}

func (d *BulkCreateAlertsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BulkCreateAlertsRequest{}
}

func (d *BulkCreateAlertsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BulkCreateAlertsResponse{}
}

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

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

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

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

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

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

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

func (d *BulkCreateAlertsDescriptor) GetVerb() string {
	return "bulkCreateAlerts"
}

func (d *BulkCreateAlertsDescriptor) GetMethodName() string {
	return "BulkCreateAlerts"
}

func (d *BulkCreateAlertsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertService/BulkCreateAlerts"
}

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

func (d *BulkCreateAlertsDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func (d *BulkCreateAlertsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertServiceDescriptor
}

func (d *BulkCreateAlertsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alert.GetDescriptor()
}

func (d *BulkCreateAlertsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BulkCreateAlertsDescriptorClientMsgHandle{}
}

func (d *BulkCreateAlertsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BulkCreateAlertsDescriptorServerMsgHandle{}
}

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

func (h *BulkCreateAlertsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BulkCreateAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BulkCreateAlertsRequest) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *BulkCreateAlertsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BulkCreateAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BulkCreateAlertsRequest) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BulkCreateAlertsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BulkCreateAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BulkCreateAlertsRequest) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *BulkCreateAlertsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BulkCreateAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BulkCreateAlertsResponse) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *BulkCreateAlertsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BulkCreateAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BulkCreateAlertsResponse) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BulkCreateAlertsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BulkCreateAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BulkCreateAlertsResponse) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetBulkCreateAlertsDescriptor() *BulkCreateAlertsDescriptor {
	return bulkCreateAlertsDescriptor
}

type BulkUpdateAlertsDescriptor struct{}

type BulkUpdateAlertsDescriptorClientMsgHandle struct{}

type BulkUpdateAlertsDescriptorServerMsgHandle struct{}

func (d *BulkUpdateAlertsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BulkUpdateAlertsRequest{}
}

func (d *BulkUpdateAlertsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BulkUpdateAlertsResponse{}
}

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

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

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

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

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

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

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

func (d *BulkUpdateAlertsDescriptor) GetVerb() string {
	return "bulkUpdateAlerts"
}

func (d *BulkUpdateAlertsDescriptor) GetMethodName() string {
	return "BulkUpdateAlerts"
}

func (d *BulkUpdateAlertsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.AlertService/BulkUpdateAlerts"
}

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

func (d *BulkUpdateAlertsDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func (d *BulkUpdateAlertsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return alertServiceDescriptor
}

func (d *BulkUpdateAlertsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return alert.GetDescriptor()
}

func (d *BulkUpdateAlertsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BulkUpdateAlertsDescriptorClientMsgHandle{}
}

func (d *BulkUpdateAlertsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BulkUpdateAlertsDescriptorServerMsgHandle{}
}

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

func (h *BulkUpdateAlertsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BulkUpdateAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BulkUpdateAlertsRequest) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *BulkUpdateAlertsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BulkUpdateAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BulkUpdateAlertsRequest) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BulkUpdateAlertsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BulkUpdateAlertsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BulkUpdateAlertsRequest) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *BulkUpdateAlertsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BulkUpdateAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BulkUpdateAlertsResponse) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *BulkUpdateAlertsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BulkUpdateAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BulkUpdateAlertsResponse) *alert.Alert
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BulkUpdateAlertsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BulkUpdateAlertsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BulkUpdateAlertsResponse) []*alert.Alert
	})
	if ok {
		return alert.AlertList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetBulkUpdateAlertsDescriptor() *BulkUpdateAlertsDescriptor {
	return bulkUpdateAlertsDescriptor
}

type AlertServiceDescriptor struct{}

func (d *AlertServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getAlertDescriptor,
		batchGetAlertsDescriptor,
		listAlertsDescriptor,
		watchAlertDescriptor,
		watchAlertsDescriptor,
		updateAlertDescriptor,
		deleteAlertDescriptor,
		bulkCreateAlertsDescriptor,
		bulkUpdateAlertsDescriptor,
	}
}

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

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

func (d *AlertServiceDescriptor) GetApiName() string {
	return "AlertService"
}

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

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

func GetAlertServiceDescriptor() *AlertServiceDescriptor {
	return alertServiceDescriptor
}

func initDescriptors() {
	alertServiceDescriptor = &AlertServiceDescriptor{}
	getAlertDescriptor = &GetAlertDescriptor{}
	batchGetAlertsDescriptor = &BatchGetAlertsDescriptor{}
	listAlertsDescriptor = &ListAlertsDescriptor{}
	watchAlertDescriptor = &WatchAlertDescriptor{}
	watchAlertsDescriptor = &WatchAlertsDescriptor{}
	updateAlertDescriptor = &UpdateAlertDescriptor{}
	deleteAlertDescriptor = &DeleteAlertDescriptor{}
	bulkCreateAlertsDescriptor = &BulkCreateAlertsDescriptor{}
	bulkUpdateAlertsDescriptor = &BulkUpdateAlertsDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(alertServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getAlertDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetAlertsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listAlertsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchAlertDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchAlertsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateAlertDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteAlertDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(bulkCreateAlertsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(bulkUpdateAlertsDescriptor)
}

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