probing_session_service.pb.descriptors.go

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

package probing_session_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 (
	probing_session "github.com/cloudwan/watchdog-sdk/resources/v1alpha2/probing_session"
	empty "github.com/golang/protobuf/ptypes/empty"
)

// 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 (
	_ = &empty.Empty{}
	_ = &probing_session.ProbingSession{}
)

var (
	descriptorsInitialized            bool
	probingSessionServiceDescriptor   *ProbingSessionServiceDescriptor
	getProbingSessionDescriptor       *GetProbingSessionDescriptor
	batchGetProbingSessionsDescriptor *BatchGetProbingSessionsDescriptor
	listProbingSessionsDescriptor     *ListProbingSessionsDescriptor
	watchProbingSessionDescriptor     *WatchProbingSessionDescriptor
	watchProbingSessionsDescriptor    *WatchProbingSessionsDescriptor
	createProbingSessionDescriptor    *CreateProbingSessionDescriptor
	updateProbingSessionDescriptor    *UpdateProbingSessionDescriptor
	deleteProbingSessionDescriptor    *DeleteProbingSessionDescriptor
	searchProbingSessionsDescriptor   *SearchProbingSessionsDescriptor
)

type GetProbingSessionDescriptor struct{}

type GetProbingSessionDescriptorClientMsgHandle struct{}

type GetProbingSessionDescriptorServerMsgHandle struct{}

func (d *GetProbingSessionDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetProbingSessionRequest{}
}

func (d *GetProbingSessionDescriptor) NewEmptyServerMsg() proto.Message {
	return &probing_session.ProbingSession{}
}

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

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

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

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

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

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

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

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

func (d *GetProbingSessionDescriptor) GetMethodName() string {
	return "GetProbingSession"
}

func (d *GetProbingSessionDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService/GetProbingSession"
}

func (d *GetProbingSessionDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *GetProbingSessionDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *GetProbingSessionDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *GetProbingSessionDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *GetProbingSessionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probingSessionServiceDescriptor
}

func (d *GetProbingSessionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probing_session.GetDescriptor()
}

func (d *GetProbingSessionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetProbingSessionDescriptorClientMsgHandle{}
}

func (d *GetProbingSessionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetProbingSessionDescriptorServerMsgHandle{}
}

func (h *GetProbingSessionDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*GetProbingSessionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*GetProbingSessionRequest) *probing_session.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if ref := typedMsg.GetName(); ref != nil {
			return &ref.Name
		}
	}
	return (*probing_session.Name)(nil)
}

func (h *GetProbingSessionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetProbingSessionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetProbingSessionRequest) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *GetProbingSessionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*probing_session.ProbingSession)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*probing_session.ProbingSession) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetGetProbingSessionDescriptor() *GetProbingSessionDescriptor {
	return getProbingSessionDescriptor
}

type BatchGetProbingSessionsDescriptor struct{}

type BatchGetProbingSessionsDescriptorClientMsgHandle struct{}

type BatchGetProbingSessionsDescriptorServerMsgHandle struct{}

func (d *BatchGetProbingSessionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetProbingSessionsRequest{}
}

func (d *BatchGetProbingSessionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetProbingSessionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetProbingSessionsDescriptor) GetMethodName() string {
	return "BatchGetProbingSessions"
}

func (d *BatchGetProbingSessionsDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService/BatchGetProbingSessions"
}

func (d *BatchGetProbingSessionsDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *BatchGetProbingSessionsDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *BatchGetProbingSessionsDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *BatchGetProbingSessionsDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *BatchGetProbingSessionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probingSessionServiceDescriptor
}

func (d *BatchGetProbingSessionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probing_session.GetDescriptor()
}

func (d *BatchGetProbingSessionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetProbingSessionsDescriptorClientMsgHandle{}
}

func (d *BatchGetProbingSessionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetProbingSessionsDescriptorServerMsgHandle{}
}

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

func (h *BatchGetProbingSessionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BatchGetProbingSessionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BatchGetProbingSessionsRequest) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if refs := typedMsg.GetNames(); len(refs) > 0 {
			list := make(probing_session.ProbingSessionNameList, 0, len(refs))
			for _, ref := range refs {
				list = append(list, &ref.Name)
			}
			return list
		}
	}
	return (probing_session.ProbingSessionNameList)(nil)
}

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

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

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

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

func GetBatchGetProbingSessionsDescriptor() *BatchGetProbingSessionsDescriptor {
	return batchGetProbingSessionsDescriptor
}

type ListProbingSessionsDescriptor struct{}

type ListProbingSessionsDescriptorClientMsgHandle struct{}

type ListProbingSessionsDescriptorServerMsgHandle struct{}

func (d *ListProbingSessionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListProbingSessionsRequest{}
}

func (d *ListProbingSessionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListProbingSessionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListProbingSessionsDescriptor) GetMethodName() string {
	return "ListProbingSessions"
}

func (d *ListProbingSessionsDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService/ListProbingSessions"
}

func (d *ListProbingSessionsDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *ListProbingSessionsDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *ListProbingSessionsDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *ListProbingSessionsDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *ListProbingSessionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probingSessionServiceDescriptor
}

func (d *ListProbingSessionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probing_session.GetDescriptor()
}

func (d *ListProbingSessionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListProbingSessionsDescriptorClientMsgHandle{}
}

func (d *ListProbingSessionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListProbingSessionsDescriptorServerMsgHandle{}
}

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

func (h *ListProbingSessionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListProbingSessionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListProbingSessionsRequest) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

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

func GetListProbingSessionsDescriptor() *ListProbingSessionsDescriptor {
	return listProbingSessionsDescriptor
}

type WatchProbingSessionDescriptor struct{}

type WatchProbingSessionDescriptorClientMsgHandle struct{}

type WatchProbingSessionDescriptorServerMsgHandle struct{}

func (d *WatchProbingSessionDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchProbingSessionRequest{}
}

func (d *WatchProbingSessionDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchProbingSessionResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchProbingSessionDescriptor) GetMethodName() string {
	return "WatchProbingSession"
}

func (d *WatchProbingSessionDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService/WatchProbingSession"
}

func (d *WatchProbingSessionDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *WatchProbingSessionDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *WatchProbingSessionDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *WatchProbingSessionDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *WatchProbingSessionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probingSessionServiceDescriptor
}

func (d *WatchProbingSessionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probing_session.GetDescriptor()
}

func (d *WatchProbingSessionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProbingSessionDescriptorClientMsgHandle{}
}

func (d *WatchProbingSessionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProbingSessionDescriptorServerMsgHandle{}
}

func (h *WatchProbingSessionDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchProbingSessionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchProbingSessionRequest) *probing_session.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if ref := typedMsg.GetName(); ref != nil {
			return &ref.Name
		}
	}
	return (*probing_session.Name)(nil)
}

func (h *WatchProbingSessionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProbingSessionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProbingSessionRequest) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchProbingSessionDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchProbingSessionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchProbingSessionResponse) *probing_session.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *probing_session.ProbingSessionChange_Added_:
				return tResChange.Added.GetProbingSession().GetName()
			case *probing_session.ProbingSessionChange_Modified_:
				return tResChange.Modified.GetName()
			case *probing_session.ProbingSessionChange_Removed_:
				return tResChange.Removed.GetName()
			case *probing_session.ProbingSessionChange_Current_:
				return tResChange.Current.GetProbingSession().GetName()
			}
		}
	}
	return (*probing_session.Name)(nil)
}

func (h *WatchProbingSessionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProbingSessionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProbingSessionResponse) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetWatchProbingSessionDescriptor() *WatchProbingSessionDescriptor {
	return watchProbingSessionDescriptor
}

type WatchProbingSessionsDescriptor struct{}

type WatchProbingSessionsDescriptorClientMsgHandle struct{}

type WatchProbingSessionsDescriptorServerMsgHandle struct{}

func (d *WatchProbingSessionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchProbingSessionsRequest{}
}

func (d *WatchProbingSessionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchProbingSessionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchProbingSessionsDescriptor) GetMethodName() string {
	return "WatchProbingSessions"
}

func (d *WatchProbingSessionsDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService/WatchProbingSessions"
}

func (d *WatchProbingSessionsDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *WatchProbingSessionsDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *WatchProbingSessionsDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *WatchProbingSessionsDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *WatchProbingSessionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probingSessionServiceDescriptor
}

func (d *WatchProbingSessionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probing_session.GetDescriptor()
}

func (d *WatchProbingSessionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProbingSessionsDescriptorClientMsgHandle{}
}

func (d *WatchProbingSessionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProbingSessionsDescriptorServerMsgHandle{}
}

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

func (h *WatchProbingSessionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProbingSessionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProbingSessionsRequest) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchProbingSessionsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchProbingSessionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*WatchProbingSessionsRequest) *probing_session.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if ref := typedMsg.GetParent(); ref != nil {
			return &ref.ParentName
		}
	}
	return (*probing_session.ParentName)(nil)
}

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

func (h *WatchProbingSessionsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProbingSessionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProbingSessionsResponse) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetProbingSessionChanges(); len(resChanges) > 0 {
			list := make(probing_session.ProbingSessionNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *probing_session.ProbingSessionChange_Added_:
					list = append(list, tResChange.Added.GetProbingSession().GetName())
				case *probing_session.ProbingSessionChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *probing_session.ProbingSessionChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *probing_session.ProbingSessionChange_Current_:
					list = append(list, tResChange.Current.GetProbingSession().GetName())
				}
			}
			return list
		}
	}
	return (probing_session.ProbingSessionNameList)(nil)
}

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

func GetWatchProbingSessionsDescriptor() *WatchProbingSessionsDescriptor {
	return watchProbingSessionsDescriptor
}

type CreateProbingSessionDescriptor struct{}

type CreateProbingSessionDescriptorClientMsgHandle struct{}

type CreateProbingSessionDescriptorServerMsgHandle struct{}

func (d *CreateProbingSessionDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateProbingSessionRequest{}
}

func (d *CreateProbingSessionDescriptor) NewEmptyServerMsg() proto.Message {
	return &probing_session.ProbingSession{}
}

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

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

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

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

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

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

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

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

func (d *CreateProbingSessionDescriptor) GetMethodName() string {
	return "CreateProbingSession"
}

func (d *CreateProbingSessionDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService/CreateProbingSession"
}

func (d *CreateProbingSessionDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *CreateProbingSessionDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *CreateProbingSessionDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *CreateProbingSessionDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *CreateProbingSessionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probingSessionServiceDescriptor
}

func (d *CreateProbingSessionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probing_session.GetDescriptor()
}

func (d *CreateProbingSessionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateProbingSessionDescriptorClientMsgHandle{}
}

func (d *CreateProbingSessionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateProbingSessionDescriptorServerMsgHandle{}
}

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

func (h *CreateProbingSessionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateProbingSessionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateProbingSessionRequest) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateProbingSessionDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateProbingSessionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*CreateProbingSessionRequest) *probing_session.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if ref := typedMsg.GetParent(); ref != nil {
			return &ref.ParentName
		}
	}
	return (*probing_session.ParentName)(nil)
}

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

func (h *CreateProbingSessionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*probing_session.ProbingSession)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*probing_session.ProbingSession) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetCreateProbingSessionDescriptor() *CreateProbingSessionDescriptor {
	return createProbingSessionDescriptor
}

type UpdateProbingSessionDescriptor struct{}

type UpdateProbingSessionDescriptorClientMsgHandle struct{}

type UpdateProbingSessionDescriptorServerMsgHandle struct{}

func (d *UpdateProbingSessionDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateProbingSessionRequest{}
}

func (d *UpdateProbingSessionDescriptor) NewEmptyServerMsg() proto.Message {
	return &probing_session.ProbingSession{}
}

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

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

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

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

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

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

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

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

func (d *UpdateProbingSessionDescriptor) GetMethodName() string {
	return "UpdateProbingSession"
}

func (d *UpdateProbingSessionDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService/UpdateProbingSession"
}

func (d *UpdateProbingSessionDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *UpdateProbingSessionDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *UpdateProbingSessionDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *UpdateProbingSessionDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *UpdateProbingSessionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probingSessionServiceDescriptor
}

func (d *UpdateProbingSessionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probing_session.GetDescriptor()
}

func (d *UpdateProbingSessionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateProbingSessionDescriptorClientMsgHandle{}
}

func (d *UpdateProbingSessionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateProbingSessionDescriptorServerMsgHandle{}
}

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

func (h *UpdateProbingSessionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateProbingSessionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateProbingSessionRequest) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *UpdateProbingSessionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*probing_session.ProbingSession)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*probing_session.ProbingSession) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetUpdateProbingSessionDescriptor() *UpdateProbingSessionDescriptor {
	return updateProbingSessionDescriptor
}

type DeleteProbingSessionDescriptor struct{}

type DeleteProbingSessionDescriptorClientMsgHandle struct{}

type DeleteProbingSessionDescriptorServerMsgHandle struct{}

func (d *DeleteProbingSessionDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteProbingSessionRequest{}
}

func (d *DeleteProbingSessionDescriptor) NewEmptyServerMsg() proto.Message {
	return &empty.Empty{}
}

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

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

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

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

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

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

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

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

func (d *DeleteProbingSessionDescriptor) GetMethodName() string {
	return "DeleteProbingSession"
}

func (d *DeleteProbingSessionDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService/DeleteProbingSession"
}

func (d *DeleteProbingSessionDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *DeleteProbingSessionDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *DeleteProbingSessionDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *DeleteProbingSessionDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *DeleteProbingSessionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probingSessionServiceDescriptor
}

func (d *DeleteProbingSessionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probing_session.GetDescriptor()
}

func (d *DeleteProbingSessionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteProbingSessionDescriptorClientMsgHandle{}
}

func (d *DeleteProbingSessionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteProbingSessionDescriptorServerMsgHandle{}
}

func (h *DeleteProbingSessionDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*DeleteProbingSessionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*DeleteProbingSessionRequest) *probing_session.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if ref := typedMsg.GetName(); ref != nil {
			return &ref.Name
		}
	}
	return (*probing_session.Name)(nil)
}

func (h *DeleteProbingSessionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteProbingSessionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteProbingSessionRequest) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *DeleteProbingSessionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*empty.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*empty.Empty) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetDeleteProbingSessionDescriptor() *DeleteProbingSessionDescriptor {
	return deleteProbingSessionDescriptor
}

type SearchProbingSessionsDescriptor struct{}

type SearchProbingSessionsDescriptorClientMsgHandle struct{}

type SearchProbingSessionsDescriptorServerMsgHandle struct{}

func (d *SearchProbingSessionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &SearchProbingSessionsRequest{}
}

func (d *SearchProbingSessionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &SearchProbingSessionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *SearchProbingSessionsDescriptor) GetMethodName() string {
	return "SearchProbingSessions"
}

func (d *SearchProbingSessionsDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService/SearchProbingSessions"
}

func (d *SearchProbingSessionsDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *SearchProbingSessionsDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *SearchProbingSessionsDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *SearchProbingSessionsDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *SearchProbingSessionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probingSessionServiceDescriptor
}

func (d *SearchProbingSessionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probing_session.GetDescriptor()
}

func (d *SearchProbingSessionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchProbingSessionsDescriptorClientMsgHandle{}
}

func (d *SearchProbingSessionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchProbingSessionsDescriptorServerMsgHandle{}
}

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

func (h *SearchProbingSessionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*SearchProbingSessionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*SearchProbingSessionsRequest) []*probing_session.Name
	})
	if ok {
		return probing_session.ProbingSessionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

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

func GetSearchProbingSessionsDescriptor() *SearchProbingSessionsDescriptor {
	return searchProbingSessionsDescriptor
}

type ProbingSessionServiceDescriptor struct{}

func (d *ProbingSessionServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getProbingSessionDescriptor,
		batchGetProbingSessionsDescriptor,
		listProbingSessionsDescriptor,
		watchProbingSessionDescriptor,
		watchProbingSessionsDescriptor,
		createProbingSessionDescriptor,
		updateProbingSessionDescriptor,
		deleteProbingSessionDescriptor,
		searchProbingSessionsDescriptor,
	}
}

func (d *ProbingSessionServiceDescriptor) GetFullAPIName() string {
	return "/ntt.watchdog.v1alpha2.ProbingSessionService"
}

func (d *ProbingSessionServiceDescriptor) GetProtoPkgName() string {
	return "ntt.watchdog.v1alpha2"
}

func (d *ProbingSessionServiceDescriptor) GetApiName() string {
	return "ProbingSessionService"
}

func (d *ProbingSessionServiceDescriptor) GetServiceDomain() string {
	return "watchdog.edgelq.com"
}

func (d *ProbingSessionServiceDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func GetProbingSessionServiceDescriptor() *ProbingSessionServiceDescriptor {
	return probingSessionServiceDescriptor
}

func initDescriptors() {
	probingSessionServiceDescriptor = &ProbingSessionServiceDescriptor{}
	getProbingSessionDescriptor = &GetProbingSessionDescriptor{}
	batchGetProbingSessionsDescriptor = &BatchGetProbingSessionsDescriptor{}
	listProbingSessionsDescriptor = &ListProbingSessionsDescriptor{}
	watchProbingSessionDescriptor = &WatchProbingSessionDescriptor{}
	watchProbingSessionsDescriptor = &WatchProbingSessionsDescriptor{}
	createProbingSessionDescriptor = &CreateProbingSessionDescriptor{}
	updateProbingSessionDescriptor = &UpdateProbingSessionDescriptor{}
	deleteProbingSessionDescriptor = &DeleteProbingSessionDescriptor{}
	searchProbingSessionsDescriptor = &SearchProbingSessionsDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(probingSessionServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getProbingSessionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetProbingSessionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listProbingSessionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchProbingSessionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchProbingSessionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createProbingSessionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateProbingSessionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteProbingSessionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(searchProbingSessionsDescriptor)
}

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