notification_channel_service.pb.descriptors.go

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

package notification_channel_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_channel "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/notification_channel"
	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_channel.NotificationChannel{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized                 bool
	notificationChannelServiceDescriptor   *NotificationChannelServiceDescriptor
	getNotificationChannelDescriptor       *GetNotificationChannelDescriptor
	batchGetNotificationChannelsDescriptor *BatchGetNotificationChannelsDescriptor
	listNotificationChannelsDescriptor     *ListNotificationChannelsDescriptor
	watchNotificationChannelDescriptor     *WatchNotificationChannelDescriptor
	watchNotificationChannelsDescriptor    *WatchNotificationChannelsDescriptor
	createNotificationChannelDescriptor    *CreateNotificationChannelDescriptor
	updateNotificationChannelDescriptor    *UpdateNotificationChannelDescriptor
	deleteNotificationChannelDescriptor    *DeleteNotificationChannelDescriptor
	testNotificationChannelDescriptor      *TestNotificationChannelDescriptor
)

type GetNotificationChannelDescriptor struct{}

type GetNotificationChannelDescriptorClientMsgHandle struct{}

type GetNotificationChannelDescriptorServerMsgHandle struct{}

func (d *GetNotificationChannelDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetNotificationChannelRequest{}
}

func (d *GetNotificationChannelDescriptor) NewEmptyServerMsg() proto.Message {
	return &notification_channel.NotificationChannel{}
}

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

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

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

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

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

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

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

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

func (d *GetNotificationChannelDescriptor) GetMethodName() string {
	return "GetNotificationChannel"
}

func (d *GetNotificationChannelDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.NotificationChannelService/GetNotificationChannel"
}

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

func (d *GetNotificationChannelDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func (d *GetNotificationChannelDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationChannelServiceDescriptor
}

func (d *GetNotificationChannelDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification_channel.GetDescriptor()
}

func (d *GetNotificationChannelDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetNotificationChannelDescriptorClientMsgHandle{}
}

func (d *GetNotificationChannelDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetNotificationChannelDescriptorServerMsgHandle{}
}

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

func (h *GetNotificationChannelDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetNotificationChannelRequest) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetNotificationChannelDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetNotificationChannelRequest) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetNotificationChannelDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetNotificationChannelRequest) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetNotificationChannelDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*notification_channel.NotificationChannel)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*notification_channel.NotificationChannel) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetNotificationChannelDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*notification_channel.NotificationChannel)
}

func (h *GetNotificationChannelDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*notification_channel.NotificationChannel)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*notification_channel.NotificationChannel) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetNotificationChannelDescriptor() *GetNotificationChannelDescriptor {
	return getNotificationChannelDescriptor
}

type BatchGetNotificationChannelsDescriptor struct{}

type BatchGetNotificationChannelsDescriptorClientMsgHandle struct{}

type BatchGetNotificationChannelsDescriptorServerMsgHandle struct{}

func (d *BatchGetNotificationChannelsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetNotificationChannelsRequest{}
}

func (d *BatchGetNotificationChannelsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetNotificationChannelsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetNotificationChannelsDescriptor) GetMethodName() string {
	return "BatchGetNotificationChannels"
}

func (d *BatchGetNotificationChannelsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.NotificationChannelService/BatchGetNotificationChannels"
}

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

func (d *BatchGetNotificationChannelsDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func (d *BatchGetNotificationChannelsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationChannelServiceDescriptor
}

func (d *BatchGetNotificationChannelsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification_channel.GetDescriptor()
}

func (d *BatchGetNotificationChannelsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetNotificationChannelsDescriptorClientMsgHandle{}
}

func (d *BatchGetNotificationChannelsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetNotificationChannelsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetNotificationChannelsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetNotificationChannelsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetNotificationChannelsRequest) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetNotificationChannelsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetNotificationChannelsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetNotificationChannelsRequest) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetNotificationChannelsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetNotificationChannelsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetNotificationChannelsResponse) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetNotificationChannelsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetNotificationChannelsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetNotificationChannelsResponse) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetNotificationChannels(); len(resources) > 0 {
			return notification_channel.NotificationChannelList(resources)
		}
	}
	return (notification_channel.NotificationChannelList)(nil)
}

func GetBatchGetNotificationChannelsDescriptor() *BatchGetNotificationChannelsDescriptor {
	return batchGetNotificationChannelsDescriptor
}

type ListNotificationChannelsDescriptor struct{}

type ListNotificationChannelsDescriptorClientMsgHandle struct{}

type ListNotificationChannelsDescriptorServerMsgHandle struct{}

func (d *ListNotificationChannelsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListNotificationChannelsRequest{}
}

func (d *ListNotificationChannelsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListNotificationChannelsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListNotificationChannelsDescriptor) GetMethodName() string {
	return "ListNotificationChannels"
}

func (d *ListNotificationChannelsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.NotificationChannelService/ListNotificationChannels"
}

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

func (d *ListNotificationChannelsDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func (d *ListNotificationChannelsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationChannelServiceDescriptor
}

func (d *ListNotificationChannelsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification_channel.GetDescriptor()
}

func (d *ListNotificationChannelsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListNotificationChannelsDescriptorClientMsgHandle{}
}

func (d *ListNotificationChannelsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListNotificationChannelsDescriptorServerMsgHandle{}
}

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

func (h *ListNotificationChannelsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListNotificationChannelsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListNotificationChannelsRequest) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListNotificationChannelsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListNotificationChannelsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListNotificationChannelsRequest) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListNotificationChannelsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListNotificationChannelsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListNotificationChannelsRequest) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListNotificationChannelsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListNotificationChannelsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListNotificationChannelsResponse) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListNotificationChannelsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListNotificationChannelsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListNotificationChannelsResponse) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetNotificationChannels(); len(resources) > 0 {
			return notification_channel.NotificationChannelList(resources)
		}
	}
	return (notification_channel.NotificationChannelList)(nil)
}

func GetListNotificationChannelsDescriptor() *ListNotificationChannelsDescriptor {
	return listNotificationChannelsDescriptor
}

type WatchNotificationChannelDescriptor struct{}

type WatchNotificationChannelDescriptorClientMsgHandle struct{}

type WatchNotificationChannelDescriptorServerMsgHandle struct{}

func (d *WatchNotificationChannelDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchNotificationChannelRequest{}
}

func (d *WatchNotificationChannelDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchNotificationChannelResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchNotificationChannelDescriptor) GetMethodName() string {
	return "WatchNotificationChannel"
}

func (d *WatchNotificationChannelDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.NotificationChannelService/WatchNotificationChannel"
}

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

func (d *WatchNotificationChannelDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func (d *WatchNotificationChannelDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationChannelServiceDescriptor
}

func (d *WatchNotificationChannelDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification_channel.GetDescriptor()
}

func (d *WatchNotificationChannelDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchNotificationChannelDescriptorClientMsgHandle{}
}

func (d *WatchNotificationChannelDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchNotificationChannelDescriptorServerMsgHandle{}
}

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

func (h *WatchNotificationChannelDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchNotificationChannelRequest) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchNotificationChannelDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchNotificationChannelRequest) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchNotificationChannelDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchNotificationChannelRequest) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchNotificationChannelDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchNotificationChannelResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchNotificationChannelResponse) *notification_channel.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *notification_channel.NotificationChannelChange_Added_:
				return tResChange.Added.GetNotificationChannel().GetName()
			case *notification_channel.NotificationChannelChange_Modified_:
				return tResChange.Modified.GetName()
			case *notification_channel.NotificationChannelChange_Removed_:
				return tResChange.Removed.GetName()
			case *notification_channel.NotificationChannelChange_Current_:
				return tResChange.Current.GetNotificationChannel().GetName()
			}
		}
	}
	return (*notification_channel.Name)(nil)
}

func (h *WatchNotificationChannelDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchNotificationChannelResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchNotificationChannelResponse) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchNotificationChannelDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchNotificationChannelResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchNotificationChannelResponse) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *notification_channel.NotificationChannelChange_Added_:
				return tResChange.Added.GetNotificationChannel()
			case *notification_channel.NotificationChannelChange_Modified_:
				return tResChange.Modified.GetNotificationChannel()
			case *notification_channel.NotificationChannelChange_Current_:
				return tResChange.Current.GetNotificationChannel()
			}
		}
	}
	return (*notification_channel.NotificationChannel)(nil)
}

func (h *WatchNotificationChannelDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchNotificationChannelResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchNotificationChannelResponse) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchNotificationChannelDescriptor() *WatchNotificationChannelDescriptor {
	return watchNotificationChannelDescriptor
}

type WatchNotificationChannelsDescriptor struct{}

type WatchNotificationChannelsDescriptorClientMsgHandle struct{}

type WatchNotificationChannelsDescriptorServerMsgHandle struct{}

func (d *WatchNotificationChannelsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchNotificationChannelsRequest{}
}

func (d *WatchNotificationChannelsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchNotificationChannelsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchNotificationChannelsDescriptor) GetMethodName() string {
	return "WatchNotificationChannels"
}

func (d *WatchNotificationChannelsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.NotificationChannelService/WatchNotificationChannels"
}

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

func (d *WatchNotificationChannelsDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func (d *WatchNotificationChannelsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationChannelServiceDescriptor
}

func (d *WatchNotificationChannelsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification_channel.GetDescriptor()
}

func (d *WatchNotificationChannelsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchNotificationChannelsDescriptorClientMsgHandle{}
}

func (d *WatchNotificationChannelsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchNotificationChannelsDescriptorServerMsgHandle{}
}

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

func (h *WatchNotificationChannelsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchNotificationChannelsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchNotificationChannelsRequest) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchNotificationChannelsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchNotificationChannelsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchNotificationChannelsRequest) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchNotificationChannelsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchNotificationChannelsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchNotificationChannelsRequest) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchNotificationChannelsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchNotificationChannelsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchNotificationChannelsResponse) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetNotificationChannelChanges(); len(resChanges) > 0 {
			list := make(notification_channel.NotificationChannelNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *notification_channel.NotificationChannelChange_Added_:
					list = append(list, tResChange.Added.GetNotificationChannel().GetName())
				case *notification_channel.NotificationChannelChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *notification_channel.NotificationChannelChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *notification_channel.NotificationChannelChange_Current_:
					list = append(list, tResChange.Current.GetNotificationChannel().GetName())
				}
			}
			return list
		}
	}
	return (notification_channel.NotificationChannelNameList)(nil)
}

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

func (h *WatchNotificationChannelsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchNotificationChannelsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchNotificationChannelsResponse) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchNotificationChannelsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchNotificationChannelsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchNotificationChannelsResponse) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetNotificationChannelChanges(); len(resChanges) > 0 {
			list := make(notification_channel.NotificationChannelList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *notification_channel.NotificationChannelChange_Added_:
					list = append(list, tResChange.Added.GetNotificationChannel())
				case *notification_channel.NotificationChannelChange_Modified_:
					list = append(list, tResChange.Modified.GetNotificationChannel())
				case *notification_channel.NotificationChannelChange_Current_:
					list = append(list, tResChange.Current.GetNotificationChannel())
				}
			}
			return list
		}
	}
	return (notification_channel.NotificationChannelList)(nil)
}

func GetWatchNotificationChannelsDescriptor() *WatchNotificationChannelsDescriptor {
	return watchNotificationChannelsDescriptor
}

type CreateNotificationChannelDescriptor struct{}

type CreateNotificationChannelDescriptorClientMsgHandle struct{}

type CreateNotificationChannelDescriptorServerMsgHandle struct{}

func (d *CreateNotificationChannelDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateNotificationChannelRequest{}
}

func (d *CreateNotificationChannelDescriptor) NewEmptyServerMsg() proto.Message {
	return &notification_channel.NotificationChannel{}
}

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

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

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

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

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

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

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

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

func (d *CreateNotificationChannelDescriptor) GetMethodName() string {
	return "CreateNotificationChannel"
}

func (d *CreateNotificationChannelDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.NotificationChannelService/CreateNotificationChannel"
}

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

func (d *CreateNotificationChannelDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func (d *CreateNotificationChannelDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationChannelServiceDescriptor
}

func (d *CreateNotificationChannelDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification_channel.GetDescriptor()
}

func (d *CreateNotificationChannelDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateNotificationChannelDescriptorClientMsgHandle{}
}

func (d *CreateNotificationChannelDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateNotificationChannelDescriptorServerMsgHandle{}
}

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

func (h *CreateNotificationChannelDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateNotificationChannelRequest) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateNotificationChannelDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateNotificationChannelRequest) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetNotificationChannel()
	}
	return (*notification_channel.NotificationChannel)(nil)
}

func (h *CreateNotificationChannelDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateNotificationChannelRequest) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateNotificationChannelDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*notification_channel.NotificationChannel)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*notification_channel.NotificationChannel) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateNotificationChannelDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*notification_channel.NotificationChannel)
}

func (h *CreateNotificationChannelDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*notification_channel.NotificationChannel)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*notification_channel.NotificationChannel) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateNotificationChannelDescriptor() *CreateNotificationChannelDescriptor {
	return createNotificationChannelDescriptor
}

type UpdateNotificationChannelDescriptor struct{}

type UpdateNotificationChannelDescriptorClientMsgHandle struct{}

type UpdateNotificationChannelDescriptorServerMsgHandle struct{}

func (d *UpdateNotificationChannelDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateNotificationChannelRequest{}
}

func (d *UpdateNotificationChannelDescriptor) NewEmptyServerMsg() proto.Message {
	return &notification_channel.NotificationChannel{}
}

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

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

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

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

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

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

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

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

func (d *UpdateNotificationChannelDescriptor) GetMethodName() string {
	return "UpdateNotificationChannel"
}

func (d *UpdateNotificationChannelDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.NotificationChannelService/UpdateNotificationChannel"
}

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

func (d *UpdateNotificationChannelDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func (d *UpdateNotificationChannelDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationChannelServiceDescriptor
}

func (d *UpdateNotificationChannelDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification_channel.GetDescriptor()
}

func (d *UpdateNotificationChannelDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateNotificationChannelDescriptorClientMsgHandle{}
}

func (d *UpdateNotificationChannelDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateNotificationChannelDescriptorServerMsgHandle{}
}

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

func (h *UpdateNotificationChannelDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateNotificationChannelRequest) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateNotificationChannelDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateNotificationChannelRequest) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetNotificationChannel()
	}
	return (*notification_channel.NotificationChannel)(nil)
}

func (h *UpdateNotificationChannelDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateNotificationChannelRequest) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateNotificationChannelDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*notification_channel.NotificationChannel)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*notification_channel.NotificationChannel) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateNotificationChannelDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*notification_channel.NotificationChannel)
}

func (h *UpdateNotificationChannelDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*notification_channel.NotificationChannel)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*notification_channel.NotificationChannel) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateNotificationChannelDescriptor() *UpdateNotificationChannelDescriptor {
	return updateNotificationChannelDescriptor
}

type DeleteNotificationChannelDescriptor struct{}

type DeleteNotificationChannelDescriptorClientMsgHandle struct{}

type DeleteNotificationChannelDescriptorServerMsgHandle struct{}

func (d *DeleteNotificationChannelDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteNotificationChannelRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteNotificationChannelDescriptor) GetMethodName() string {
	return "DeleteNotificationChannel"
}

func (d *DeleteNotificationChannelDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.NotificationChannelService/DeleteNotificationChannel"
}

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

func (d *DeleteNotificationChannelDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func (d *DeleteNotificationChannelDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationChannelServiceDescriptor
}

func (d *DeleteNotificationChannelDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification_channel.GetDescriptor()
}

func (d *DeleteNotificationChannelDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteNotificationChannelDescriptorClientMsgHandle{}
}

func (d *DeleteNotificationChannelDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteNotificationChannelDescriptorServerMsgHandle{}
}

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

func (h *DeleteNotificationChannelDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteNotificationChannelRequest) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteNotificationChannelDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteNotificationChannelRequest) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteNotificationChannelDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteNotificationChannelRequest) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteNotificationChannelDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteNotificationChannelDescriptor() *DeleteNotificationChannelDescriptor {
	return deleteNotificationChannelDescriptor
}

type TestNotificationChannelDescriptor struct{}

type TestNotificationChannelDescriptorClientMsgHandle struct{}

type TestNotificationChannelDescriptorServerMsgHandle struct{}

func (d *TestNotificationChannelDescriptor) NewEmptyClientMsg() proto.Message {
	return &TestNotificationChannelRequest{}
}

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

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

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

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

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

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

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

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

func (d *TestNotificationChannelDescriptor) GetVerb() string {
	return "test"
}

func (d *TestNotificationChannelDescriptor) GetMethodName() string {
	return "TestNotificationChannel"
}

func (d *TestNotificationChannelDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v3.NotificationChannelService/TestNotificationChannel"
}

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

func (d *TestNotificationChannelDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func (d *TestNotificationChannelDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return notificationChannelServiceDescriptor
}

func (d *TestNotificationChannelDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return notification_channel.GetDescriptor()
}

func (d *TestNotificationChannelDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &TestNotificationChannelDescriptorClientMsgHandle{}
}

func (d *TestNotificationChannelDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &TestNotificationChannelDescriptorServerMsgHandle{}
}

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

func (h *TestNotificationChannelDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*TestNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*TestNotificationChannelRequest) []*notification_channel.Name
	})
	if ok {
		return notification_channel.NotificationChannelNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *TestNotificationChannelDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*TestNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*TestNotificationChannelRequest) *notification_channel.NotificationChannel
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *TestNotificationChannelDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*TestNotificationChannelRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*TestNotificationChannelRequest) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *TestNotificationChannelDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*notification_channel.NotificationChannel
	})
	if ok {
		return notification_channel.NotificationChannelList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetTestNotificationChannelDescriptor() *TestNotificationChannelDescriptor {
	return testNotificationChannelDescriptor
}

type NotificationChannelServiceDescriptor struct{}

func (d *NotificationChannelServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getNotificationChannelDescriptor,
		batchGetNotificationChannelsDescriptor,
		listNotificationChannelsDescriptor,
		watchNotificationChannelDescriptor,
		watchNotificationChannelsDescriptor,
		createNotificationChannelDescriptor,
		updateNotificationChannelDescriptor,
		deleteNotificationChannelDescriptor,
		testNotificationChannelDescriptor,
	}
}

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

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

func (d *NotificationChannelServiceDescriptor) GetApiName() string {
	return "NotificationChannelService"
}

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

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

func GetNotificationChannelServiceDescriptor() *NotificationChannelServiceDescriptor {
	return notificationChannelServiceDescriptor
}

func initDescriptors() {
	notificationChannelServiceDescriptor = &NotificationChannelServiceDescriptor{}
	getNotificationChannelDescriptor = &GetNotificationChannelDescriptor{}
	batchGetNotificationChannelsDescriptor = &BatchGetNotificationChannelsDescriptor{}
	listNotificationChannelsDescriptor = &ListNotificationChannelsDescriptor{}
	watchNotificationChannelDescriptor = &WatchNotificationChannelDescriptor{}
	watchNotificationChannelsDescriptor = &WatchNotificationChannelsDescriptor{}
	createNotificationChannelDescriptor = &CreateNotificationChannelDescriptor{}
	updateNotificationChannelDescriptor = &UpdateNotificationChannelDescriptor{}
	deleteNotificationChannelDescriptor = &DeleteNotificationChannelDescriptor{}
	testNotificationChannelDescriptor = &TestNotificationChannelDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(notificationChannelServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getNotificationChannelDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetNotificationChannelsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listNotificationChannelsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchNotificationChannelDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchNotificationChannelsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createNotificationChannelDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateNotificationChannelDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteNotificationChannelDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(testNotificationChannelDescriptor)
}

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