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

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

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

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

var (
	descriptorsInitialized      bool
	resourceServiceDescriptor   *ResourceServiceDescriptor
	getResourceDescriptor       *GetResourceDescriptor
	batchGetResourcesDescriptor *BatchGetResourcesDescriptor
	listResourcesDescriptor     *ListResourcesDescriptor
	watchResourceDescriptor     *WatchResourceDescriptor
	watchResourcesDescriptor    *WatchResourcesDescriptor
)

type GetResourceDescriptor struct{}

type GetResourceDescriptorClientMsgHandle struct{}

type GetResourceDescriptorServerMsgHandle struct{}

func (d *GetResourceDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetResourceRequest{}
}

func (d *GetResourceDescriptor) NewEmptyServerMsg() proto.Message {
	return &resource.Resource{}
}

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

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

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

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

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

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

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

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

func (d *GetResourceDescriptor) GetMethodName() string {
	return "GetResource"
}

func (d *GetResourceDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ResourceService/GetResource"
}

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

func (d *GetResourceDescriptor) GetApiName() string {
	return "ResourceService"
}

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

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

func (d *GetResourceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return resourceServiceDescriptor
}

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

func (d *GetResourceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetResourceDescriptorClientMsgHandle{}
}

func (d *GetResourceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetResourceDescriptorServerMsgHandle{}
}

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

func (h *GetResourceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetResourceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetResourceRequest) []*resource.Name
	})
	if ok {
		return resource.ResourceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetResourceDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetResourceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetResourceRequest) *resource.Resource
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetResourceDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetResourceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetResourceRequest) []*resource.Resource
	})
	if ok {
		return resource.ResourceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetResourceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*resource.Resource)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*resource.Resource) []*resource.Name
	})
	if ok {
		return resource.ResourceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetResourceDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*resource.Resource)
}

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

func GetGetResourceDescriptor() *GetResourceDescriptor {
	return getResourceDescriptor
}

type BatchGetResourcesDescriptor struct{}

type BatchGetResourcesDescriptorClientMsgHandle struct{}

type BatchGetResourcesDescriptorServerMsgHandle struct{}

func (d *BatchGetResourcesDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetResourcesRequest{}
}

func (d *BatchGetResourcesDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetResourcesResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetResourcesDescriptor) GetMethodName() string {
	return "BatchGetResources"
}

func (d *BatchGetResourcesDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ResourceService/BatchGetResources"
}

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

func (d *BatchGetResourcesDescriptor) GetApiName() string {
	return "ResourceService"
}

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

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

func (d *BatchGetResourcesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return resourceServiceDescriptor
}

func (d *BatchGetResourcesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return resource.GetDescriptor()
}

func (d *BatchGetResourcesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetResourcesDescriptorClientMsgHandle{}
}

func (d *BatchGetResourcesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetResourcesDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetResourcesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetResourcesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetResourcesRequest) *resource.Resource
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetResourcesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetResourcesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetResourcesRequest) []*resource.Resource
	})
	if ok {
		return resource.ResourceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetResourcesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetResourcesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetResourcesResponse) *resource.Resource
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetResourcesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetResourcesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetResourcesResponse) []*resource.Resource
	})
	if ok {
		return resource.ResourceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetResources(); len(resources) > 0 {
			return resource.ResourceList(resources)
		}
	}
	return (resource.ResourceList)(nil)
}

func GetBatchGetResourcesDescriptor() *BatchGetResourcesDescriptor {
	return batchGetResourcesDescriptor
}

type ListResourcesDescriptor struct{}

type ListResourcesDescriptorClientMsgHandle struct{}

type ListResourcesDescriptorServerMsgHandle struct{}

func (d *ListResourcesDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListResourcesRequest{}
}

func (d *ListResourcesDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListResourcesResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListResourcesDescriptor) GetMethodName() string {
	return "ListResources"
}

func (d *ListResourcesDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ResourceService/ListResources"
}

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

func (d *ListResourcesDescriptor) GetApiName() string {
	return "ResourceService"
}

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

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

func (d *ListResourcesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return resourceServiceDescriptor
}

func (d *ListResourcesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return resource.GetDescriptor()
}

func (d *ListResourcesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListResourcesDescriptorClientMsgHandle{}
}

func (d *ListResourcesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListResourcesDescriptorServerMsgHandle{}
}

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

func (h *ListResourcesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListResourcesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListResourcesRequest) []*resource.Name
	})
	if ok {
		return resource.ResourceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListResourcesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListResourcesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListResourcesRequest) *resource.Resource
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListResourcesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListResourcesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListResourcesRequest) []*resource.Resource
	})
	if ok {
		return resource.ResourceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListResourcesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListResourcesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListResourcesResponse) *resource.Resource
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListResourcesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListResourcesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListResourcesResponse) []*resource.Resource
	})
	if ok {
		return resource.ResourceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetResources(); len(resources) > 0 {
			return resource.ResourceList(resources)
		}
	}
	return (resource.ResourceList)(nil)
}

func GetListResourcesDescriptor() *ListResourcesDescriptor {
	return listResourcesDescriptor
}

type WatchResourceDescriptor struct{}

type WatchResourceDescriptorClientMsgHandle struct{}

type WatchResourceDescriptorServerMsgHandle struct{}

func (d *WatchResourceDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchResourceRequest{}
}

func (d *WatchResourceDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchResourceResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchResourceDescriptor) GetMethodName() string {
	return "WatchResource"
}

func (d *WatchResourceDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ResourceService/WatchResource"
}

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

func (d *WatchResourceDescriptor) GetApiName() string {
	return "ResourceService"
}

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

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

func (d *WatchResourceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return resourceServiceDescriptor
}

func (d *WatchResourceDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return resource.GetDescriptor()
}

func (d *WatchResourceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchResourceDescriptorClientMsgHandle{}
}

func (d *WatchResourceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchResourceDescriptorServerMsgHandle{}
}

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

func (h *WatchResourceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchResourceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchResourceRequest) []*resource.Name
	})
	if ok {
		return resource.ResourceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchResourceDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchResourceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchResourceRequest) *resource.Resource
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchResourceDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchResourceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchResourceRequest) []*resource.Resource
	})
	if ok {
		return resource.ResourceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchResourceDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchResourceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchResourceResponse) *resource.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *resource.ResourceChange_Added_:
				return tResChange.Added.GetResource().GetName()
			case *resource.ResourceChange_Modified_:
				return tResChange.Modified.GetName()
			case *resource.ResourceChange_Removed_:
				return tResChange.Removed.GetName()
			case *resource.ResourceChange_Current_:
				return tResChange.Current.GetResource().GetName()
			}
		}
	}
	return (*resource.Name)(nil)
}

func (h *WatchResourceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchResourceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchResourceResponse) []*resource.Name
	})
	if ok {
		return resource.ResourceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchResourceDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchResourceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchResourceResponse) *resource.Resource
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *resource.ResourceChange_Added_:
				return tResChange.Added.GetResource()
			case *resource.ResourceChange_Modified_:
				return tResChange.Modified.GetResource()
			case *resource.ResourceChange_Current_:
				return tResChange.Current.GetResource()
			}
		}
	}
	return (*resource.Resource)(nil)
}

func (h *WatchResourceDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchResourceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchResourceResponse) []*resource.Resource
	})
	if ok {
		return resource.ResourceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchResourceDescriptor() *WatchResourceDescriptor {
	return watchResourceDescriptor
}

type WatchResourcesDescriptor struct{}

type WatchResourcesDescriptorClientMsgHandle struct{}

type WatchResourcesDescriptorServerMsgHandle struct{}

func (d *WatchResourcesDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchResourcesRequest{}
}

func (d *WatchResourcesDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchResourcesResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchResourcesDescriptor) GetMethodName() string {
	return "WatchResources"
}

func (d *WatchResourcesDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.ResourceService/WatchResources"
}

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

func (d *WatchResourcesDescriptor) GetApiName() string {
	return "ResourceService"
}

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

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

func (d *WatchResourcesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return resourceServiceDescriptor
}

func (d *WatchResourcesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return resource.GetDescriptor()
}

func (d *WatchResourcesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchResourcesDescriptorClientMsgHandle{}
}

func (d *WatchResourcesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchResourcesDescriptorServerMsgHandle{}
}

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

func (h *WatchResourcesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchResourcesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchResourcesRequest) []*resource.Name
	})
	if ok {
		return resource.ResourceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchResourcesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchResourcesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchResourcesRequest) *resource.Resource
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchResourcesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchResourcesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchResourcesRequest) []*resource.Resource
	})
	if ok {
		return resource.ResourceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchResourcesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchResourcesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchResourcesResponse) []*resource.Name
	})
	if ok {
		return resource.ResourceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetResourceChanges(); len(resChanges) > 0 {
			list := make(resource.ResourceNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *resource.ResourceChange_Added_:
					list = append(list, tResChange.Added.GetResource().GetName())
				case *resource.ResourceChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *resource.ResourceChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *resource.ResourceChange_Current_:
					list = append(list, tResChange.Current.GetResource().GetName())
				}
			}
			return list
		}
	}
	return (resource.ResourceNameList)(nil)
}

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

func (h *WatchResourcesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchResourcesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchResourcesResponse) *resource.Resource
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchResourcesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchResourcesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchResourcesResponse) []*resource.Resource
	})
	if ok {
		return resource.ResourceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetResourceChanges(); len(resChanges) > 0 {
			list := make(resource.ResourceList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *resource.ResourceChange_Added_:
					list = append(list, tResChange.Added.GetResource())
				case *resource.ResourceChange_Modified_:
					list = append(list, tResChange.Modified.GetResource())
				case *resource.ResourceChange_Current_:
					list = append(list, tResChange.Current.GetResource())
				}
			}
			return list
		}
	}
	return (resource.ResourceList)(nil)
}

func GetWatchResourcesDescriptor() *WatchResourcesDescriptor {
	return watchResourcesDescriptor
}

type ResourceServiceDescriptor struct{}

func (d *ResourceServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getResourceDescriptor,
		batchGetResourcesDescriptor,
		listResourcesDescriptor,
		watchResourceDescriptor,
		watchResourcesDescriptor,
	}
}

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

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

func (d *ResourceServiceDescriptor) GetApiName() string {
	return "ResourceService"
}

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

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

func GetResourceServiceDescriptor() *ResourceServiceDescriptor {
	return resourceServiceDescriptor
}

func initDescriptors() {
	resourceServiceDescriptor = &ResourceServiceDescriptor{}
	getResourceDescriptor = &GetResourceDescriptor{}
	batchGetResourcesDescriptor = &BatchGetResourcesDescriptor{}
	listResourcesDescriptor = &ListResourcesDescriptor{}
	watchResourceDescriptor = &WatchResourceDescriptor{}
	watchResourcesDescriptor = &WatchResourcesDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(resourceServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getResourceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetResourcesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listResourcesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchResourceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchResourcesDescriptor)
}

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