probe_service.pb.descriptors.go

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

package probe_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 (
	probe "github.com/cloudwan/watchdog-sdk/resources/v1alpha2/probe"
	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{}
	_ = &probe.Probe{}
)

var (
	descriptorsInitialized   bool
	probeServiceDescriptor   *ProbeServiceDescriptor
	getProbeDescriptor       *GetProbeDescriptor
	batchGetProbesDescriptor *BatchGetProbesDescriptor
	listProbesDescriptor     *ListProbesDescriptor
	watchProbeDescriptor     *WatchProbeDescriptor
	watchProbesDescriptor    *WatchProbesDescriptor
	createProbeDescriptor    *CreateProbeDescriptor
	updateProbeDescriptor    *UpdateProbeDescriptor
	deleteProbeDescriptor    *DeleteProbeDescriptor
	searchProbesDescriptor   *SearchProbesDescriptor
	listMyProbesDescriptor   *ListMyProbesDescriptor
)

type GetProbeDescriptor struct{}

type GetProbeDescriptorClientMsgHandle struct{}

type GetProbeDescriptorServerMsgHandle struct{}

func (d *GetProbeDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetProbeRequest{}
}

func (d *GetProbeDescriptor) NewEmptyServerMsg() proto.Message {
	return &probe.Probe{}
}

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

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

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

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

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

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

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

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

func (d *GetProbeDescriptor) GetMethodName() string {
	return "GetProbe"
}

func (d *GetProbeDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/GetProbe"
}

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

func (d *GetProbeDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *GetProbeDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *GetProbeDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *GetProbeDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetProbeDescriptorClientMsgHandle{}
}

func (d *GetProbeDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetProbeDescriptorServerMsgHandle{}
}

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

func (h *GetProbeDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetProbeRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetProbeRequest) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *GetProbeDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*probe.Probe)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*probe.Probe) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetGetProbeDescriptor() *GetProbeDescriptor {
	return getProbeDescriptor
}

type BatchGetProbesDescriptor struct{}

type BatchGetProbesDescriptorClientMsgHandle struct{}

type BatchGetProbesDescriptorServerMsgHandle struct{}

func (d *BatchGetProbesDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetProbesRequest{}
}

func (d *BatchGetProbesDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetProbesResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetProbesDescriptor) GetMethodName() string {
	return "BatchGetProbes"
}

func (d *BatchGetProbesDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/BatchGetProbes"
}

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

func (d *BatchGetProbesDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *BatchGetProbesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *BatchGetProbesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *BatchGetProbesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetProbesDescriptorClientMsgHandle{}
}

func (d *BatchGetProbesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetProbesDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

func GetBatchGetProbesDescriptor() *BatchGetProbesDescriptor {
	return batchGetProbesDescriptor
}

type ListProbesDescriptor struct{}

type ListProbesDescriptorClientMsgHandle struct{}

type ListProbesDescriptorServerMsgHandle struct{}

func (d *ListProbesDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListProbesRequest{}
}

func (d *ListProbesDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListProbesResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListProbesDescriptor) GetMethodName() string {
	return "ListProbes"
}

func (d *ListProbesDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/ListProbes"
}

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

func (d *ListProbesDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *ListProbesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *ListProbesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *ListProbesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListProbesDescriptorClientMsgHandle{}
}

func (d *ListProbesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListProbesDescriptorServerMsgHandle{}
}

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

func (h *ListProbesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListProbesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListProbesRequest) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

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

func GetListProbesDescriptor() *ListProbesDescriptor {
	return listProbesDescriptor
}

type WatchProbeDescriptor struct{}

type WatchProbeDescriptorClientMsgHandle struct{}

type WatchProbeDescriptorServerMsgHandle struct{}

func (d *WatchProbeDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchProbeRequest{}
}

func (d *WatchProbeDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchProbeResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchProbeDescriptor) GetMethodName() string {
	return "WatchProbe"
}

func (d *WatchProbeDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/WatchProbe"
}

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

func (d *WatchProbeDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *WatchProbeDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *WatchProbeDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *WatchProbeDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProbeDescriptorClientMsgHandle{}
}

func (d *WatchProbeDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProbeDescriptorServerMsgHandle{}
}

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

func (h *WatchProbeDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProbeRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProbeRequest) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchProbeDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchProbeResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchProbeResponse) *probe.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *probe.ProbeChange_Added_:
				return tResChange.Added.GetProbe().GetName()
			case *probe.ProbeChange_Modified_:
				return tResChange.Modified.GetName()
			case *probe.ProbeChange_Removed_:
				return tResChange.Removed.GetName()
			case *probe.ProbeChange_Current_:
				return tResChange.Current.GetProbe().GetName()
			}
		}
	}
	return (*probe.Name)(nil)
}

func (h *WatchProbeDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProbeResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProbeResponse) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetWatchProbeDescriptor() *WatchProbeDescriptor {
	return watchProbeDescriptor
}

type WatchProbesDescriptor struct{}

type WatchProbesDescriptorClientMsgHandle struct{}

type WatchProbesDescriptorServerMsgHandle struct{}

func (d *WatchProbesDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchProbesRequest{}
}

func (d *WatchProbesDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchProbesResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchProbesDescriptor) GetMethodName() string {
	return "WatchProbes"
}

func (d *WatchProbesDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/WatchProbes"
}

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

func (d *WatchProbesDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *WatchProbesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *WatchProbesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *WatchProbesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProbesDescriptorClientMsgHandle{}
}

func (d *WatchProbesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProbesDescriptorServerMsgHandle{}
}

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

func (h *WatchProbesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProbesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProbesRequest) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *WatchProbesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProbesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProbesResponse) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetProbeChanges(); len(resChanges) > 0 {
			list := make(probe.ProbeNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *probe.ProbeChange_Added_:
					list = append(list, tResChange.Added.GetProbe().GetName())
				case *probe.ProbeChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *probe.ProbeChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *probe.ProbeChange_Current_:
					list = append(list, tResChange.Current.GetProbe().GetName())
				}
			}
			return list
		}
	}
	return (probe.ProbeNameList)(nil)
}

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

func GetWatchProbesDescriptor() *WatchProbesDescriptor {
	return watchProbesDescriptor
}

type CreateProbeDescriptor struct{}

type CreateProbeDescriptorClientMsgHandle struct{}

type CreateProbeDescriptorServerMsgHandle struct{}

func (d *CreateProbeDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateProbeRequest{}
}

func (d *CreateProbeDescriptor) NewEmptyServerMsg() proto.Message {
	return &probe.Probe{}
}

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

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

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

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

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

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

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

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

func (d *CreateProbeDescriptor) GetMethodName() string {
	return "CreateProbe"
}

func (d *CreateProbeDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/CreateProbe"
}

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

func (d *CreateProbeDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *CreateProbeDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *CreateProbeDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *CreateProbeDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateProbeDescriptorClientMsgHandle{}
}

func (d *CreateProbeDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateProbeDescriptorServerMsgHandle{}
}

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

func (h *CreateProbeDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateProbeRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateProbeRequest) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *CreateProbeDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*probe.Probe)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*probe.Probe) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetCreateProbeDescriptor() *CreateProbeDescriptor {
	return createProbeDescriptor
}

type UpdateProbeDescriptor struct{}

type UpdateProbeDescriptorClientMsgHandle struct{}

type UpdateProbeDescriptorServerMsgHandle struct{}

func (d *UpdateProbeDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateProbeRequest{}
}

func (d *UpdateProbeDescriptor) NewEmptyServerMsg() proto.Message {
	return &probe.Probe{}
}

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

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

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

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

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

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

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

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

func (d *UpdateProbeDescriptor) GetMethodName() string {
	return "UpdateProbe"
}

func (d *UpdateProbeDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/UpdateProbe"
}

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

func (d *UpdateProbeDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *UpdateProbeDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *UpdateProbeDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *UpdateProbeDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateProbeDescriptorClientMsgHandle{}
}

func (d *UpdateProbeDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateProbeDescriptorServerMsgHandle{}
}

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

func (h *UpdateProbeDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateProbeRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateProbeRequest) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *UpdateProbeDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*probe.Probe)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*probe.Probe) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetUpdateProbeDescriptor() *UpdateProbeDescriptor {
	return updateProbeDescriptor
}

type DeleteProbeDescriptor struct{}

type DeleteProbeDescriptorClientMsgHandle struct{}

type DeleteProbeDescriptorServerMsgHandle struct{}

func (d *DeleteProbeDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteProbeRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteProbeDescriptor) GetMethodName() string {
	return "DeleteProbe"
}

func (d *DeleteProbeDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/DeleteProbe"
}

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

func (d *DeleteProbeDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *DeleteProbeDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *DeleteProbeDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *DeleteProbeDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteProbeDescriptorClientMsgHandle{}
}

func (d *DeleteProbeDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteProbeDescriptorServerMsgHandle{}
}

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

func (h *DeleteProbeDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteProbeRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteProbeRequest) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

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

func GetDeleteProbeDescriptor() *DeleteProbeDescriptor {
	return deleteProbeDescriptor
}

type SearchProbesDescriptor struct{}

type SearchProbesDescriptorClientMsgHandle struct{}

type SearchProbesDescriptorServerMsgHandle struct{}

func (d *SearchProbesDescriptor) NewEmptyClientMsg() proto.Message {
	return &SearchProbesRequest{}
}

func (d *SearchProbesDescriptor) NewEmptyServerMsg() proto.Message {
	return &SearchProbesResponse{}
}

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

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

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

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

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

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

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

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

func (d *SearchProbesDescriptor) GetMethodName() string {
	return "SearchProbes"
}

func (d *SearchProbesDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/SearchProbes"
}

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

func (d *SearchProbesDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *SearchProbesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *SearchProbesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *SearchProbesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchProbesDescriptorClientMsgHandle{}
}

func (d *SearchProbesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchProbesDescriptorServerMsgHandle{}
}

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

func (h *SearchProbesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*SearchProbesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*SearchProbesRequest) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

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

func GetSearchProbesDescriptor() *SearchProbesDescriptor {
	return searchProbesDescriptor
}

type ListMyProbesDescriptor struct{}

type ListMyProbesDescriptorClientMsgHandle struct{}

type ListMyProbesDescriptorServerMsgHandle struct{}

func (d *ListMyProbesDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListProbesRequest{}
}

func (d *ListMyProbesDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListProbesResponse{}
}

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

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

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

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

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

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

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

func (d *ListMyProbesDescriptor) GetVerb() string {
	return "listMy"
}

func (d *ListMyProbesDescriptor) GetMethodName() string {
	return "ListMyProbes"
}

func (d *ListMyProbesDescriptor) GetFullMethodName() string {
	return "/ntt.watchdog.v1alpha2.ProbeService/ListMyProbes"
}

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

func (d *ListMyProbesDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func (d *ListMyProbesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return probeServiceDescriptor
}

func (d *ListMyProbesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return probe.GetDescriptor()
}

func (d *ListMyProbesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListMyProbesDescriptorClientMsgHandle{}
}

func (d *ListMyProbesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListMyProbesDescriptorServerMsgHandle{}
}

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

func (h *ListMyProbesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListProbesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListProbesRequest) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *ListMyProbesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListProbesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListProbesResponse) []*probe.Name
	})
	if ok {
		return probe.ProbeNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetListMyProbesDescriptor() *ListMyProbesDescriptor {
	return listMyProbesDescriptor
}

type ProbeServiceDescriptor struct{}

func (d *ProbeServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getProbeDescriptor,
		batchGetProbesDescriptor,
		listProbesDescriptor,
		watchProbeDescriptor,
		watchProbesDescriptor,
		createProbeDescriptor,
		updateProbeDescriptor,
		deleteProbeDescriptor,
		searchProbesDescriptor,
		listMyProbesDescriptor,
	}
}

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

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

func (d *ProbeServiceDescriptor) GetApiName() string {
	return "ProbeService"
}

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

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

func GetProbeServiceDescriptor() *ProbeServiceDescriptor {
	return probeServiceDescriptor
}

func initDescriptors() {
	probeServiceDescriptor = &ProbeServiceDescriptor{}
	getProbeDescriptor = &GetProbeDescriptor{}
	batchGetProbesDescriptor = &BatchGetProbesDescriptor{}
	listProbesDescriptor = &ListProbesDescriptor{}
	watchProbeDescriptor = &WatchProbeDescriptor{}
	watchProbesDescriptor = &WatchProbesDescriptor{}
	createProbeDescriptor = &CreateProbeDescriptor{}
	updateProbeDescriptor = &UpdateProbeDescriptor{}
	deleteProbeDescriptor = &DeleteProbeDescriptor{}
	searchProbesDescriptor = &SearchProbesDescriptor{}
	listMyProbesDescriptor = &ListMyProbesDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(probeServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getProbeDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetProbesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listProbesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchProbeDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchProbesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createProbeDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateProbeDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteProbeDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(searchProbesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listMyProbesDescriptor)
}

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