github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/client/v1/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/alerting/resources/v1/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
	createAlertDescriptor        *CreateAlertDescriptor
	updateAlertDescriptor        *UpdateAlertDescriptor
	deleteAlertDescriptor        *DeleteAlertDescriptor
	bulkSaveAlertsDescriptor     *BulkSaveAlertsDescriptor
	bulkMarkAsNotifiedDescriptor *BulkMarkAsNotifiedDescriptor
)

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.alerting.v1.AlertService/GetAlert"
}

func (d *GetAlertDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

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

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

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.alerting.v1.AlertService/BatchGetAlerts"
}

func (d *BatchGetAlertsDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

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

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

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.alerting.v1.AlertService/ListAlerts"
}

func (d *ListAlertsDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

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

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

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.alerting.v1.AlertService/WatchAlert"
}

func (d *WatchAlertDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

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

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

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.alerting.v1.AlertService/WatchAlerts"
}

func (d *WatchAlertsDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

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

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

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 CreateAlertDescriptor struct{}

type CreateAlertDescriptorClientMsgHandle struct{}

type CreateAlertDescriptorServerMsgHandle struct{}

func (d *CreateAlertDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateAlertRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *CreateAlertDescriptor) GetMethodName() string {
	return "CreateAlert"
}

func (d *CreateAlertDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.AlertService/CreateAlert"
}

func (d *CreateAlertDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

func (d *CreateAlertDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

func (d *CreateAlertDescriptor) GetServiceVersion() string {
	return "v1"
}

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

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

func (d *CreateAlertDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateAlertDescriptorClientMsgHandle{}
}

func (d *CreateAlertDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateAlertDescriptorServerMsgHandle{}
}

func (h *CreateAlertDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*CreateAlertRequest) *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 *CreateAlertDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateAlertRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateAlertRequest) []*alert.Name
	})
	if ok {
		return alert.AlertNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

func (h *CreateAlertDescriptorServerMsgHandle) 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 *CreateAlertDescriptorServerMsgHandle) 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 *CreateAlertDescriptorServerMsgHandle) 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 *CreateAlertDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*alert.Alert)
}

func (h *CreateAlertDescriptorServerMsgHandle) 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 GetCreateAlertDescriptor() *CreateAlertDescriptor {
	return createAlertDescriptor
}

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.alerting.v1.AlertService/UpdateAlert"
}

func (d *UpdateAlertDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

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

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

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.alerting.v1.AlertService/DeleteAlert"
}

func (d *DeleteAlertDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

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

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

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 BulkSaveAlertsDescriptor struct{}

type BulkSaveAlertsDescriptorClientMsgHandle struct{}

type BulkSaveAlertsDescriptorServerMsgHandle struct{}

func (d *BulkSaveAlertsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BulkSaveAlertsRequest{}
}

func (d *BulkSaveAlertsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BulkSaveAlertsResponse{}
}

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

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

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

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

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

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

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

func (d *BulkSaveAlertsDescriptor) GetVerb() string {
	return "bulkSaveAlerts"
}

func (d *BulkSaveAlertsDescriptor) GetMethodName() string {
	return "BulkSaveAlerts"
}

func (d *BulkSaveAlertsDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.AlertService/BulkSaveAlerts"
}

func (d *BulkSaveAlertsDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

func (d *BulkSaveAlertsDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

func (d *BulkSaveAlertsDescriptor) GetServiceVersion() string {
	return "v1"
}

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

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

func (d *BulkSaveAlertsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BulkSaveAlertsDescriptorClientMsgHandle{}
}

func (d *BulkSaveAlertsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BulkSaveAlertsDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

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

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

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

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

func GetBulkSaveAlertsDescriptor() *BulkSaveAlertsDescriptor {
	return bulkSaveAlertsDescriptor
}

type BulkMarkAsNotifiedDescriptor struct{}

type BulkMarkAsNotifiedDescriptorClientMsgHandle struct{}

type BulkMarkAsNotifiedDescriptorServerMsgHandle struct{}

func (d *BulkMarkAsNotifiedDescriptor) NewEmptyClientMsg() proto.Message {
	return &BulkMarkAsNotifiedRequest{}
}

func (d *BulkMarkAsNotifiedDescriptor) NewEmptyServerMsg() proto.Message {
	return &BulkMarkAsNotifiedResponse{}
}

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

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

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

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

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

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

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

func (d *BulkMarkAsNotifiedDescriptor) GetVerb() string {
	return "bulkMarkAsNotified"
}

func (d *BulkMarkAsNotifiedDescriptor) GetMethodName() string {
	return "BulkMarkAsNotified"
}

func (d *BulkMarkAsNotifiedDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.AlertService/BulkMarkAsNotified"
}

func (d *BulkMarkAsNotifiedDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

func (d *BulkMarkAsNotifiedDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

func (d *BulkMarkAsNotifiedDescriptor) GetServiceVersion() string {
	return "v1"
}

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

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

func (d *BulkMarkAsNotifiedDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BulkMarkAsNotifiedDescriptorClientMsgHandle{}
}

func (d *BulkMarkAsNotifiedDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BulkMarkAsNotifiedDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

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

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

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

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

func GetBulkMarkAsNotifiedDescriptor() *BulkMarkAsNotifiedDescriptor {
	return bulkMarkAsNotifiedDescriptor
}

type AlertServiceDescriptor struct{}

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

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

func (d *AlertServiceDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

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

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

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

func GetAlertServiceDescriptor() *AlertServiceDescriptor {
	return alertServiceDescriptor
}

func initDescriptors() {
	alertServiceDescriptor = &AlertServiceDescriptor{}
	getAlertDescriptor = &GetAlertDescriptor{}
	batchGetAlertsDescriptor = &BatchGetAlertsDescriptor{}
	listAlertsDescriptor = &ListAlertsDescriptor{}
	watchAlertDescriptor = &WatchAlertDescriptor{}
	watchAlertsDescriptor = &WatchAlertsDescriptor{}
	createAlertDescriptor = &CreateAlertDescriptor{}
	updateAlertDescriptor = &UpdateAlertDescriptor{}
	deleteAlertDescriptor = &DeleteAlertDescriptor{}
	bulkSaveAlertsDescriptor = &BulkSaveAlertsDescriptor{}
	bulkMarkAsNotifiedDescriptor = &BulkMarkAsNotifiedDescriptor{}
	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(createAlertDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateAlertDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteAlertDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(bulkSaveAlertsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(bulkMarkAsNotifiedDescriptor)
}

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