github.com/cloudwan/edgelq-sdk@v1.15.4/meta/client/v1alpha2/service/service_service.pb.descriptors.go

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

package service_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 (
	service "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/service"
)

// 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 (
	_ = &service.Service{}
)

var (
	descriptorsInitialized     bool
	serviceServiceDescriptor   *ServiceServiceDescriptor
	getServiceDescriptor       *GetServiceDescriptor
	batchGetServicesDescriptor *BatchGetServicesDescriptor
	listServicesDescriptor     *ListServicesDescriptor
	watchServiceDescriptor     *WatchServiceDescriptor
	watchServicesDescriptor    *WatchServicesDescriptor
)

type GetServiceDescriptor struct{}

type GetServiceDescriptorClientMsgHandle struct{}

type GetServiceDescriptorServerMsgHandle struct{}

func (d *GetServiceDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetServiceRequest{}
}

func (d *GetServiceDescriptor) NewEmptyServerMsg() proto.Message {
	return &service.Service{}
}

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

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

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

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

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

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

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

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

func (d *GetServiceDescriptor) GetMethodName() string {
	return "GetService"
}

func (d *GetServiceDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ServiceService/GetService"
}

func (d *GetServiceDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *GetServiceDescriptor) GetApiName() string {
	return "ServiceService"
}

func (d *GetServiceDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *GetServiceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceServiceDescriptor
}

func (d *GetServiceDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return service.GetDescriptor()
}

func (d *GetServiceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetServiceDescriptorClientMsgHandle{}
}

func (d *GetServiceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetServiceDescriptorServerMsgHandle{}
}

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

func (h *GetServiceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetServiceRequest) []*service.Name
	})
	if ok {
		return service.ServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *GetServiceDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *GetServiceDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetServiceRequest) *service.Service
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetServiceDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetServiceRequest) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetServiceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*service.Service)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*service.Service) []*service.Name
	})
	if ok {
		return service.ServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *GetServiceDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *GetServiceDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*service.Service)
}

func (h *GetServiceDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*service.Service)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*service.Service) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetServiceDescriptor() *GetServiceDescriptor {
	return getServiceDescriptor
}

type BatchGetServicesDescriptor struct{}

type BatchGetServicesDescriptorClientMsgHandle struct{}

type BatchGetServicesDescriptorServerMsgHandle struct{}

func (d *BatchGetServicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetServicesRequest{}
}

func (d *BatchGetServicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetServicesResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetServicesDescriptor) GetMethodName() string {
	return "BatchGetServices"
}

func (d *BatchGetServicesDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ServiceService/BatchGetServices"
}

func (d *BatchGetServicesDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *BatchGetServicesDescriptor) GetApiName() string {
	return "ServiceService"
}

func (d *BatchGetServicesDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *BatchGetServicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceServiceDescriptor
}

func (d *BatchGetServicesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return service.GetDescriptor()
}

func (d *BatchGetServicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetServicesDescriptorClientMsgHandle{}
}

func (d *BatchGetServicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetServicesDescriptorServerMsgHandle{}
}

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

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

func (h *BatchGetServicesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *BatchGetServicesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetServicesRequest) *service.Service
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetServicesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetServicesRequest) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *BatchGetServicesDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *BatchGetServicesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetServicesResponse) *service.Service
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetServicesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetServicesResponse) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetServices(); len(resources) > 0 {
			return service.ServiceList(resources)
		}
	}
	return (service.ServiceList)(nil)
}

func GetBatchGetServicesDescriptor() *BatchGetServicesDescriptor {
	return batchGetServicesDescriptor
}

type ListServicesDescriptor struct{}

type ListServicesDescriptorClientMsgHandle struct{}

type ListServicesDescriptorServerMsgHandle struct{}

func (d *ListServicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListServicesRequest{}
}

func (d *ListServicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListServicesResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListServicesDescriptor) GetMethodName() string {
	return "ListServices"
}

func (d *ListServicesDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ServiceService/ListServices"
}

func (d *ListServicesDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *ListServicesDescriptor) GetApiName() string {
	return "ServiceService"
}

func (d *ListServicesDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *ListServicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceServiceDescriptor
}

func (d *ListServicesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return service.GetDescriptor()
}

func (d *ListServicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListServicesDescriptorClientMsgHandle{}
}

func (d *ListServicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListServicesDescriptorServerMsgHandle{}
}

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

func (h *ListServicesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListServicesRequest) []*service.Name
	})
	if ok {
		return service.ServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListServicesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListServicesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListServicesRequest) *service.Service
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListServicesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListServicesRequest) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *ListServicesDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListServicesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListServicesResponse) *service.Service
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListServicesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListServicesResponse) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetServices(); len(resources) > 0 {
			return service.ServiceList(resources)
		}
	}
	return (service.ServiceList)(nil)
}

func GetListServicesDescriptor() *ListServicesDescriptor {
	return listServicesDescriptor
}

type WatchServiceDescriptor struct{}

type WatchServiceDescriptorClientMsgHandle struct{}

type WatchServiceDescriptorServerMsgHandle struct{}

func (d *WatchServiceDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchServiceRequest{}
}

func (d *WatchServiceDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchServiceResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchServiceDescriptor) GetMethodName() string {
	return "WatchService"
}

func (d *WatchServiceDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ServiceService/WatchService"
}

func (d *WatchServiceDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *WatchServiceDescriptor) GetApiName() string {
	return "ServiceService"
}

func (d *WatchServiceDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *WatchServiceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceServiceDescriptor
}

func (d *WatchServiceDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return service.GetDescriptor()
}

func (d *WatchServiceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchServiceDescriptorClientMsgHandle{}
}

func (d *WatchServiceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchServiceDescriptorServerMsgHandle{}
}

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

func (h *WatchServiceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchServiceRequest) []*service.Name
	})
	if ok {
		return service.ServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchServiceDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchServiceDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchServiceRequest) *service.Service
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchServiceDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchServiceRequest) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchServiceDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchServiceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchServiceResponse) *service.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *service.ServiceChange_Added_:
				return tResChange.Added.GetService().GetName()
			case *service.ServiceChange_Modified_:
				return tResChange.Modified.GetName()
			case *service.ServiceChange_Removed_:
				return tResChange.Removed.GetName()
			case *service.ServiceChange_Current_:
				return tResChange.Current.GetService().GetName()
			}
		}
	}
	return (*service.Name)(nil)
}

func (h *WatchServiceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchServiceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchServiceResponse) []*service.Name
	})
	if ok {
		return service.ServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchServiceDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchServiceDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchServiceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchServiceResponse) *service.Service
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *service.ServiceChange_Added_:
				return tResChange.Added.GetService()
			case *service.ServiceChange_Modified_:
				return tResChange.Modified.GetService()
			case *service.ServiceChange_Current_:
				return tResChange.Current.GetService()
			}
		}
	}
	return (*service.Service)(nil)
}

func (h *WatchServiceDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchServiceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchServiceResponse) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchServiceDescriptor() *WatchServiceDescriptor {
	return watchServiceDescriptor
}

type WatchServicesDescriptor struct{}

type WatchServicesDescriptorClientMsgHandle struct{}

type WatchServicesDescriptorServerMsgHandle struct{}

func (d *WatchServicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchServicesRequest{}
}

func (d *WatchServicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchServicesResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchServicesDescriptor) GetMethodName() string {
	return "WatchServices"
}

func (d *WatchServicesDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ServiceService/WatchServices"
}

func (d *WatchServicesDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *WatchServicesDescriptor) GetApiName() string {
	return "ServiceService"
}

func (d *WatchServicesDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *WatchServicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceServiceDescriptor
}

func (d *WatchServicesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return service.GetDescriptor()
}

func (d *WatchServicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchServicesDescriptorClientMsgHandle{}
}

func (d *WatchServicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchServicesDescriptorServerMsgHandle{}
}

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

func (h *WatchServicesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchServicesRequest) []*service.Name
	})
	if ok {
		return service.ServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchServicesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchServicesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchServicesRequest) *service.Service
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchServicesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchServicesRequest) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchServicesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchServicesResponse) []*service.Name
	})
	if ok {
		return service.ServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetServiceChanges(); len(resChanges) > 0 {
			list := make(service.ServiceNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *service.ServiceChange_Added_:
					list = append(list, tResChange.Added.GetService().GetName())
				case *service.ServiceChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *service.ServiceChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *service.ServiceChange_Current_:
					list = append(list, tResChange.Current.GetService().GetName())
				}
			}
			return list
		}
	}
	return (service.ServiceNameList)(nil)
}

func (h *WatchServicesDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchServicesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchServicesResponse) *service.Service
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchServicesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchServicesResponse) []*service.Service
	})
	if ok {
		return service.ServiceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetServiceChanges(); len(resChanges) > 0 {
			list := make(service.ServiceList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *service.ServiceChange_Added_:
					list = append(list, tResChange.Added.GetService())
				case *service.ServiceChange_Modified_:
					list = append(list, tResChange.Modified.GetService())
				case *service.ServiceChange_Current_:
					list = append(list, tResChange.Current.GetService())
				}
			}
			return list
		}
	}
	return (service.ServiceList)(nil)
}

func GetWatchServicesDescriptor() *WatchServicesDescriptor {
	return watchServicesDescriptor
}

type ServiceServiceDescriptor struct{}

func (d *ServiceServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getServiceDescriptor,
		batchGetServicesDescriptor,
		listServicesDescriptor,
		watchServiceDescriptor,
		watchServicesDescriptor,
	}
}

func (d *ServiceServiceDescriptor) GetFullAPIName() string {
	return "/ntt.meta.v1alpha2.ServiceService"
}

func (d *ServiceServiceDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *ServiceServiceDescriptor) GetApiName() string {
	return "ServiceService"
}

func (d *ServiceServiceDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func GetServiceServiceDescriptor() *ServiceServiceDescriptor {
	return serviceServiceDescriptor
}

func initDescriptors() {
	serviceServiceDescriptor = &ServiceServiceDescriptor{}
	getServiceDescriptor = &GetServiceDescriptor{}
	batchGetServicesDescriptor = &BatchGetServicesDescriptor{}
	listServicesDescriptor = &ListServicesDescriptor{}
	watchServiceDescriptor = &WatchServiceDescriptor{}
	watchServicesDescriptor = &WatchServicesDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(serviceServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetServicesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listServicesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchServicesDescriptor)
}

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