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

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

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

var (
	descriptorsInitialized          bool
	notificationServiceDescriptor   *NotificationServiceDescriptor
	getNotificationDescriptor       *GetNotificationDescriptor
	batchGetNotificationsDescriptor *BatchGetNotificationsDescriptor
	listNotificationsDescriptor     *ListNotificationsDescriptor
	watchNotificationDescriptor     *WatchNotificationDescriptor
	watchNotificationsDescriptor    *WatchNotificationsDescriptor
	createNotificationDescriptor    *CreateNotificationDescriptor
	updateNotificationDescriptor    *UpdateNotificationDescriptor
	deleteNotificationDescriptor    *DeleteNotificationDescriptor
)

type GetNotificationDescriptor struct{}

type GetNotificationDescriptorClientMsgHandle struct{}

type GetNotificationDescriptorServerMsgHandle struct{}

func (d *GetNotificationDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetNotificationRequest{}
}

func (d *GetNotificationDescriptor) NewEmptyServerMsg() proto.Message {
	return &notification.Notification{}
}

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

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

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

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

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

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

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

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

func (d *GetNotificationDescriptor) GetMethodName() string {
	return "GetNotification"
}

func (d *GetNotificationDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.NotificationService/GetNotification"
}

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

func (d *GetNotificationDescriptor) GetApiName() string {
	return "NotificationService"
}

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

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

func (d *GetNotificationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationServiceDescriptor
}

func (d *GetNotificationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification.GetDescriptor()
}

func (d *GetNotificationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetNotificationDescriptorClientMsgHandle{}
}

func (d *GetNotificationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetNotificationDescriptorServerMsgHandle{}
}

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

func (h *GetNotificationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetNotificationRequest) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetNotificationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetNotificationRequest) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetNotificationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetNotificationRequest) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetNotificationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*notification.Notification)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*notification.Notification) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetNotificationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*notification.Notification)
}

func (h *GetNotificationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*notification.Notification)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*notification.Notification) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetNotificationDescriptor() *GetNotificationDescriptor {
	return getNotificationDescriptor
}

type BatchGetNotificationsDescriptor struct{}

type BatchGetNotificationsDescriptorClientMsgHandle struct{}

type BatchGetNotificationsDescriptorServerMsgHandle struct{}

func (d *BatchGetNotificationsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetNotificationsRequest{}
}

func (d *BatchGetNotificationsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetNotificationsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetNotificationsDescriptor) GetMethodName() string {
	return "BatchGetNotifications"
}

func (d *BatchGetNotificationsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.NotificationService/BatchGetNotifications"
}

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

func (d *BatchGetNotificationsDescriptor) GetApiName() string {
	return "NotificationService"
}

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

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

func (d *BatchGetNotificationsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationServiceDescriptor
}

func (d *BatchGetNotificationsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification.GetDescriptor()
}

func (d *BatchGetNotificationsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetNotificationsDescriptorClientMsgHandle{}
}

func (d *BatchGetNotificationsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetNotificationsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetNotificationsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetNotificationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetNotificationsRequest) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetNotificationsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetNotificationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetNotificationsRequest) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetNotificationsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetNotificationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetNotificationsResponse) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetNotificationsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetNotificationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetNotificationsResponse) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetNotifications(); len(resources) > 0 {
			return notification.NotificationList(resources)
		}
	}
	return (notification.NotificationList)(nil)
}

func GetBatchGetNotificationsDescriptor() *BatchGetNotificationsDescriptor {
	return batchGetNotificationsDescriptor
}

type ListNotificationsDescriptor struct{}

type ListNotificationsDescriptorClientMsgHandle struct{}

type ListNotificationsDescriptorServerMsgHandle struct{}

func (d *ListNotificationsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListNotificationsRequest{}
}

func (d *ListNotificationsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListNotificationsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListNotificationsDescriptor) GetMethodName() string {
	return "ListNotifications"
}

func (d *ListNotificationsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.NotificationService/ListNotifications"
}

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

func (d *ListNotificationsDescriptor) GetApiName() string {
	return "NotificationService"
}

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

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

func (d *ListNotificationsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationServiceDescriptor
}

func (d *ListNotificationsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification.GetDescriptor()
}

func (d *ListNotificationsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListNotificationsDescriptorClientMsgHandle{}
}

func (d *ListNotificationsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListNotificationsDescriptorServerMsgHandle{}
}

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

func (h *ListNotificationsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListNotificationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListNotificationsRequest) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListNotificationsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListNotificationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListNotificationsRequest) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListNotificationsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListNotificationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListNotificationsRequest) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListNotificationsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListNotificationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListNotificationsResponse) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListNotificationsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListNotificationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListNotificationsResponse) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetNotifications(); len(resources) > 0 {
			return notification.NotificationList(resources)
		}
	}
	return (notification.NotificationList)(nil)
}

func GetListNotificationsDescriptor() *ListNotificationsDescriptor {
	return listNotificationsDescriptor
}

type WatchNotificationDescriptor struct{}

type WatchNotificationDescriptorClientMsgHandle struct{}

type WatchNotificationDescriptorServerMsgHandle struct{}

func (d *WatchNotificationDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchNotificationRequest{}
}

func (d *WatchNotificationDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchNotificationResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchNotificationDescriptor) GetMethodName() string {
	return "WatchNotification"
}

func (d *WatchNotificationDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.NotificationService/WatchNotification"
}

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

func (d *WatchNotificationDescriptor) GetApiName() string {
	return "NotificationService"
}

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

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

func (d *WatchNotificationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationServiceDescriptor
}

func (d *WatchNotificationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification.GetDescriptor()
}

func (d *WatchNotificationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchNotificationDescriptorClientMsgHandle{}
}

func (d *WatchNotificationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchNotificationDescriptorServerMsgHandle{}
}

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

func (h *WatchNotificationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchNotificationRequest) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchNotificationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchNotificationRequest) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchNotificationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchNotificationRequest) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchNotificationDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchNotificationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchNotificationResponse) *notification.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *notification.NotificationChange_Added_:
				return tResChange.Added.GetNotification().GetName()
			case *notification.NotificationChange_Modified_:
				return tResChange.Modified.GetName()
			case *notification.NotificationChange_Removed_:
				return tResChange.Removed.GetName()
			case *notification.NotificationChange_Current_:
				return tResChange.Current.GetNotification().GetName()
			}
		}
	}
	return (*notification.Name)(nil)
}

func (h *WatchNotificationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchNotificationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchNotificationResponse) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchNotificationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchNotificationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchNotificationResponse) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *notification.NotificationChange_Added_:
				return tResChange.Added.GetNotification()
			case *notification.NotificationChange_Modified_:
				return tResChange.Modified.GetNotification()
			case *notification.NotificationChange_Current_:
				return tResChange.Current.GetNotification()
			}
		}
	}
	return (*notification.Notification)(nil)
}

func (h *WatchNotificationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchNotificationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchNotificationResponse) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchNotificationDescriptor() *WatchNotificationDescriptor {
	return watchNotificationDescriptor
}

type WatchNotificationsDescriptor struct{}

type WatchNotificationsDescriptorClientMsgHandle struct{}

type WatchNotificationsDescriptorServerMsgHandle struct{}

func (d *WatchNotificationsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchNotificationsRequest{}
}

func (d *WatchNotificationsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchNotificationsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchNotificationsDescriptor) GetMethodName() string {
	return "WatchNotifications"
}

func (d *WatchNotificationsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.NotificationService/WatchNotifications"
}

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

func (d *WatchNotificationsDescriptor) GetApiName() string {
	return "NotificationService"
}

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

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

func (d *WatchNotificationsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationServiceDescriptor
}

func (d *WatchNotificationsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification.GetDescriptor()
}

func (d *WatchNotificationsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchNotificationsDescriptorClientMsgHandle{}
}

func (d *WatchNotificationsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchNotificationsDescriptorServerMsgHandle{}
}

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

func (h *WatchNotificationsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchNotificationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchNotificationsRequest) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchNotificationsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchNotificationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchNotificationsRequest) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchNotificationsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchNotificationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchNotificationsRequest) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchNotificationsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchNotificationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchNotificationsResponse) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetNotificationChanges(); len(resChanges) > 0 {
			list := make(notification.NotificationNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *notification.NotificationChange_Added_:
					list = append(list, tResChange.Added.GetNotification().GetName())
				case *notification.NotificationChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *notification.NotificationChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *notification.NotificationChange_Current_:
					list = append(list, tResChange.Current.GetNotification().GetName())
				}
			}
			return list
		}
	}
	return (notification.NotificationNameList)(nil)
}

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

func (h *WatchNotificationsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchNotificationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchNotificationsResponse) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchNotificationsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchNotificationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchNotificationsResponse) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetNotificationChanges(); len(resChanges) > 0 {
			list := make(notification.NotificationList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *notification.NotificationChange_Added_:
					list = append(list, tResChange.Added.GetNotification())
				case *notification.NotificationChange_Modified_:
					list = append(list, tResChange.Modified.GetNotification())
				case *notification.NotificationChange_Current_:
					list = append(list, tResChange.Current.GetNotification())
				}
			}
			return list
		}
	}
	return (notification.NotificationList)(nil)
}

func GetWatchNotificationsDescriptor() *WatchNotificationsDescriptor {
	return watchNotificationsDescriptor
}

type CreateNotificationDescriptor struct{}

type CreateNotificationDescriptorClientMsgHandle struct{}

type CreateNotificationDescriptorServerMsgHandle struct{}

func (d *CreateNotificationDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateNotificationRequest{}
}

func (d *CreateNotificationDescriptor) NewEmptyServerMsg() proto.Message {
	return &notification.Notification{}
}

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

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

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

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

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

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

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

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

func (d *CreateNotificationDescriptor) GetMethodName() string {
	return "CreateNotification"
}

func (d *CreateNotificationDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.NotificationService/CreateNotification"
}

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

func (d *CreateNotificationDescriptor) GetApiName() string {
	return "NotificationService"
}

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

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

func (d *CreateNotificationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationServiceDescriptor
}

func (d *CreateNotificationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification.GetDescriptor()
}

func (d *CreateNotificationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateNotificationDescriptorClientMsgHandle{}
}

func (d *CreateNotificationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateNotificationDescriptorServerMsgHandle{}
}

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

func (h *CreateNotificationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateNotificationRequest) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateNotificationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateNotificationRequest) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetNotification()
	}
	return (*notification.Notification)(nil)
}

func (h *CreateNotificationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateNotificationRequest) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateNotificationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*notification.Notification)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*notification.Notification) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateNotificationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*notification.Notification)
}

func (h *CreateNotificationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*notification.Notification)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*notification.Notification) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateNotificationDescriptor() *CreateNotificationDescriptor {
	return createNotificationDescriptor
}

type UpdateNotificationDescriptor struct{}

type UpdateNotificationDescriptorClientMsgHandle struct{}

type UpdateNotificationDescriptorServerMsgHandle struct{}

func (d *UpdateNotificationDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateNotificationRequest{}
}

func (d *UpdateNotificationDescriptor) NewEmptyServerMsg() proto.Message {
	return &notification.Notification{}
}

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

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

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

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

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

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

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

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

func (d *UpdateNotificationDescriptor) GetMethodName() string {
	return "UpdateNotification"
}

func (d *UpdateNotificationDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.NotificationService/UpdateNotification"
}

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

func (d *UpdateNotificationDescriptor) GetApiName() string {
	return "NotificationService"
}

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

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

func (d *UpdateNotificationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationServiceDescriptor
}

func (d *UpdateNotificationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification.GetDescriptor()
}

func (d *UpdateNotificationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateNotificationDescriptorClientMsgHandle{}
}

func (d *UpdateNotificationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateNotificationDescriptorServerMsgHandle{}
}

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

func (h *UpdateNotificationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateNotificationRequest) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateNotificationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateNotificationRequest) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetNotification()
	}
	return (*notification.Notification)(nil)
}

func (h *UpdateNotificationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateNotificationRequest) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateNotificationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*notification.Notification)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*notification.Notification) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateNotificationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*notification.Notification)
}

func (h *UpdateNotificationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*notification.Notification)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*notification.Notification) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateNotificationDescriptor() *UpdateNotificationDescriptor {
	return updateNotificationDescriptor
}

type DeleteNotificationDescriptor struct{}

type DeleteNotificationDescriptorClientMsgHandle struct{}

type DeleteNotificationDescriptorServerMsgHandle struct{}

func (d *DeleteNotificationDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteNotificationRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteNotificationDescriptor) GetMethodName() string {
	return "DeleteNotification"
}

func (d *DeleteNotificationDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.NotificationService/DeleteNotification"
}

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

func (d *DeleteNotificationDescriptor) GetApiName() string {
	return "NotificationService"
}

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

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

func (d *DeleteNotificationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationServiceDescriptor
}

func (d *DeleteNotificationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification.GetDescriptor()
}

func (d *DeleteNotificationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteNotificationDescriptorClientMsgHandle{}
}

func (d *DeleteNotificationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteNotificationDescriptorServerMsgHandle{}
}

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

func (h *DeleteNotificationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteNotificationRequest) []*notification.Name
	})
	if ok {
		return notification.NotificationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteNotificationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteNotificationRequest) *notification.Notification
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteNotificationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteNotificationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteNotificationRequest) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteNotificationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*notification.Notification
	})
	if ok {
		return notification.NotificationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteNotificationDescriptor() *DeleteNotificationDescriptor {
	return deleteNotificationDescriptor
}

type NotificationServiceDescriptor struct{}

func (d *NotificationServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getNotificationDescriptor,
		batchGetNotificationsDescriptor,
		listNotificationsDescriptor,
		watchNotificationDescriptor,
		watchNotificationsDescriptor,
		createNotificationDescriptor,
		updateNotificationDescriptor,
		deleteNotificationDescriptor,
	}
}

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

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

func (d *NotificationServiceDescriptor) GetApiName() string {
	return "NotificationService"
}

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

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

func GetNotificationServiceDescriptor() *NotificationServiceDescriptor {
	return notificationServiceDescriptor
}

func initDescriptors() {
	notificationServiceDescriptor = &NotificationServiceDescriptor{}
	getNotificationDescriptor = &GetNotificationDescriptor{}
	batchGetNotificationsDescriptor = &BatchGetNotificationsDescriptor{}
	listNotificationsDescriptor = &ListNotificationsDescriptor{}
	watchNotificationDescriptor = &WatchNotificationDescriptor{}
	watchNotificationsDescriptor = &WatchNotificationsDescriptor{}
	createNotificationDescriptor = &CreateNotificationDescriptor{}
	updateNotificationDescriptor = &UpdateNotificationDescriptor{}
	deleteNotificationDescriptor = &DeleteNotificationDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(notificationServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getNotificationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetNotificationsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listNotificationsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchNotificationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchNotificationsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createNotificationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateNotificationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteNotificationDescriptor)
}

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