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

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

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

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

var (
	descriptorsInitialized        bool
	deploymentServiceDescriptor   *DeploymentServiceDescriptor
	getDeploymentDescriptor       *GetDeploymentDescriptor
	batchGetDeploymentsDescriptor *BatchGetDeploymentsDescriptor
	listDeploymentsDescriptor     *ListDeploymentsDescriptor
	watchDeploymentDescriptor     *WatchDeploymentDescriptor
	watchDeploymentsDescriptor    *WatchDeploymentsDescriptor
)

type GetDeploymentDescriptor struct{}

type GetDeploymentDescriptorClientMsgHandle struct{}

type GetDeploymentDescriptorServerMsgHandle struct{}

func (d *GetDeploymentDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetDeploymentRequest{}
}

func (d *GetDeploymentDescriptor) NewEmptyServerMsg() proto.Message {
	return &deployment.Deployment{}
}

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

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

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

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

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

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

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

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

func (d *GetDeploymentDescriptor) GetMethodName() string {
	return "GetDeployment"
}

func (d *GetDeploymentDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.DeploymentService/GetDeployment"
}

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

func (d *GetDeploymentDescriptor) GetApiName() string {
	return "DeploymentService"
}

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

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

func (d *GetDeploymentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deploymentServiceDescriptor
}

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

func (d *GetDeploymentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetDeploymentDescriptorClientMsgHandle{}
}

func (d *GetDeploymentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetDeploymentDescriptorServerMsgHandle{}
}

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

func (h *GetDeploymentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetDeploymentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetDeploymentRequest) []*deployment.Name
	})
	if ok {
		return deployment.DeploymentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetDeploymentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetDeploymentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetDeploymentRequest) *deployment.Deployment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetDeploymentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetDeploymentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetDeploymentRequest) []*deployment.Deployment
	})
	if ok {
		return deployment.DeploymentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetDeploymentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*deployment.Deployment)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*deployment.Deployment) []*deployment.Name
	})
	if ok {
		return deployment.DeploymentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetDeploymentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*deployment.Deployment)
}

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

func GetGetDeploymentDescriptor() *GetDeploymentDescriptor {
	return getDeploymentDescriptor
}

type BatchGetDeploymentsDescriptor struct{}

type BatchGetDeploymentsDescriptorClientMsgHandle struct{}

type BatchGetDeploymentsDescriptorServerMsgHandle struct{}

func (d *BatchGetDeploymentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetDeploymentsRequest{}
}

func (d *BatchGetDeploymentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetDeploymentsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetDeploymentsDescriptor) GetMethodName() string {
	return "BatchGetDeployments"
}

func (d *BatchGetDeploymentsDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.DeploymentService/BatchGetDeployments"
}

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

func (d *BatchGetDeploymentsDescriptor) GetApiName() string {
	return "DeploymentService"
}

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

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

func (d *BatchGetDeploymentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deploymentServiceDescriptor
}

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

func (d *BatchGetDeploymentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetDeploymentsDescriptorClientMsgHandle{}
}

func (d *BatchGetDeploymentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetDeploymentsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetDeploymentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetDeploymentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetDeploymentsRequest) *deployment.Deployment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetDeploymentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetDeploymentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetDeploymentsRequest) []*deployment.Deployment
	})
	if ok {
		return deployment.DeploymentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetDeploymentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetDeploymentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetDeploymentsResponse) *deployment.Deployment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetDeploymentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetDeploymentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetDeploymentsResponse) []*deployment.Deployment
	})
	if ok {
		return deployment.DeploymentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetDeployments(); len(resources) > 0 {
			return deployment.DeploymentList(resources)
		}
	}
	return (deployment.DeploymentList)(nil)
}

func GetBatchGetDeploymentsDescriptor() *BatchGetDeploymentsDescriptor {
	return batchGetDeploymentsDescriptor
}

type ListDeploymentsDescriptor struct{}

type ListDeploymentsDescriptorClientMsgHandle struct{}

type ListDeploymentsDescriptorServerMsgHandle struct{}

func (d *ListDeploymentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListDeploymentsRequest{}
}

func (d *ListDeploymentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListDeploymentsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListDeploymentsDescriptor) GetMethodName() string {
	return "ListDeployments"
}

func (d *ListDeploymentsDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.DeploymentService/ListDeployments"
}

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

func (d *ListDeploymentsDescriptor) GetApiName() string {
	return "DeploymentService"
}

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

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

func (d *ListDeploymentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deploymentServiceDescriptor
}

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

func (d *ListDeploymentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListDeploymentsDescriptorClientMsgHandle{}
}

func (d *ListDeploymentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListDeploymentsDescriptorServerMsgHandle{}
}

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

func (h *ListDeploymentsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListDeploymentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListDeploymentsRequest) []*deployment.Name
	})
	if ok {
		return deployment.DeploymentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListDeploymentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListDeploymentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListDeploymentsRequest) *deployment.Deployment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListDeploymentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListDeploymentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListDeploymentsRequest) []*deployment.Deployment
	})
	if ok {
		return deployment.DeploymentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListDeploymentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListDeploymentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListDeploymentsResponse) *deployment.Deployment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListDeploymentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListDeploymentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListDeploymentsResponse) []*deployment.Deployment
	})
	if ok {
		return deployment.DeploymentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetDeployments(); len(resources) > 0 {
			return deployment.DeploymentList(resources)
		}
	}
	return (deployment.DeploymentList)(nil)
}

func GetListDeploymentsDescriptor() *ListDeploymentsDescriptor {
	return listDeploymentsDescriptor
}

type WatchDeploymentDescriptor struct{}

type WatchDeploymentDescriptorClientMsgHandle struct{}

type WatchDeploymentDescriptorServerMsgHandle struct{}

func (d *WatchDeploymentDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchDeploymentRequest{}
}

func (d *WatchDeploymentDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchDeploymentResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchDeploymentDescriptor) GetMethodName() string {
	return "WatchDeployment"
}

func (d *WatchDeploymentDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.DeploymentService/WatchDeployment"
}

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

func (d *WatchDeploymentDescriptor) GetApiName() string {
	return "DeploymentService"
}

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

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

func (d *WatchDeploymentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deploymentServiceDescriptor
}

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

func (d *WatchDeploymentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDeploymentDescriptorClientMsgHandle{}
}

func (d *WatchDeploymentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDeploymentDescriptorServerMsgHandle{}
}

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

func (h *WatchDeploymentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchDeploymentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchDeploymentRequest) []*deployment.Name
	})
	if ok {
		return deployment.DeploymentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchDeploymentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchDeploymentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchDeploymentRequest) *deployment.Deployment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchDeploymentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchDeploymentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchDeploymentRequest) []*deployment.Deployment
	})
	if ok {
		return deployment.DeploymentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchDeploymentDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchDeploymentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchDeploymentResponse) *deployment.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *deployment.DeploymentChange_Added_:
				return tResChange.Added.GetDeployment().GetName()
			case *deployment.DeploymentChange_Modified_:
				return tResChange.Modified.GetName()
			case *deployment.DeploymentChange_Removed_:
				return tResChange.Removed.GetName()
			case *deployment.DeploymentChange_Current_:
				return tResChange.Current.GetDeployment().GetName()
			}
		}
	}
	return (*deployment.Name)(nil)
}

func (h *WatchDeploymentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchDeploymentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchDeploymentResponse) []*deployment.Name
	})
	if ok {
		return deployment.DeploymentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchDeploymentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchDeploymentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchDeploymentResponse) *deployment.Deployment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *deployment.DeploymentChange_Added_:
				return tResChange.Added.GetDeployment()
			case *deployment.DeploymentChange_Modified_:
				return tResChange.Modified.GetDeployment()
			case *deployment.DeploymentChange_Current_:
				return tResChange.Current.GetDeployment()
			}
		}
	}
	return (*deployment.Deployment)(nil)
}

func (h *WatchDeploymentDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchDeploymentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchDeploymentResponse) []*deployment.Deployment
	})
	if ok {
		return deployment.DeploymentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchDeploymentDescriptor() *WatchDeploymentDescriptor {
	return watchDeploymentDescriptor
}

type WatchDeploymentsDescriptor struct{}

type WatchDeploymentsDescriptorClientMsgHandle struct{}

type WatchDeploymentsDescriptorServerMsgHandle struct{}

func (d *WatchDeploymentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchDeploymentsRequest{}
}

func (d *WatchDeploymentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchDeploymentsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchDeploymentsDescriptor) GetMethodName() string {
	return "WatchDeployments"
}

func (d *WatchDeploymentsDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.DeploymentService/WatchDeployments"
}

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

func (d *WatchDeploymentsDescriptor) GetApiName() string {
	return "DeploymentService"
}

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

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

func (d *WatchDeploymentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deploymentServiceDescriptor
}

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

func (d *WatchDeploymentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDeploymentsDescriptorClientMsgHandle{}
}

func (d *WatchDeploymentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDeploymentsDescriptorServerMsgHandle{}
}

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

func (h *WatchDeploymentsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchDeploymentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchDeploymentsRequest) []*deployment.Name
	})
	if ok {
		return deployment.DeploymentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchDeploymentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchDeploymentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchDeploymentsRequest) *deployment.Deployment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchDeploymentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchDeploymentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchDeploymentsRequest) []*deployment.Deployment
	})
	if ok {
		return deployment.DeploymentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchDeploymentsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchDeploymentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchDeploymentsResponse) []*deployment.Name
	})
	if ok {
		return deployment.DeploymentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetDeploymentChanges(); len(resChanges) > 0 {
			list := make(deployment.DeploymentNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *deployment.DeploymentChange_Added_:
					list = append(list, tResChange.Added.GetDeployment().GetName())
				case *deployment.DeploymentChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *deployment.DeploymentChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *deployment.DeploymentChange_Current_:
					list = append(list, tResChange.Current.GetDeployment().GetName())
				}
			}
			return list
		}
	}
	return (deployment.DeploymentNameList)(nil)
}

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

func (h *WatchDeploymentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchDeploymentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchDeploymentsResponse) *deployment.Deployment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchDeploymentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchDeploymentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchDeploymentsResponse) []*deployment.Deployment
	})
	if ok {
		return deployment.DeploymentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetDeploymentChanges(); len(resChanges) > 0 {
			list := make(deployment.DeploymentList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *deployment.DeploymentChange_Added_:
					list = append(list, tResChange.Added.GetDeployment())
				case *deployment.DeploymentChange_Modified_:
					list = append(list, tResChange.Modified.GetDeployment())
				case *deployment.DeploymentChange_Current_:
					list = append(list, tResChange.Current.GetDeployment())
				}
			}
			return list
		}
	}
	return (deployment.DeploymentList)(nil)
}

func GetWatchDeploymentsDescriptor() *WatchDeploymentsDescriptor {
	return watchDeploymentsDescriptor
}

type DeploymentServiceDescriptor struct{}

func (d *DeploymentServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getDeploymentDescriptor,
		batchGetDeploymentsDescriptor,
		listDeploymentsDescriptor,
		watchDeploymentDescriptor,
		watchDeploymentsDescriptor,
	}
}

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

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

func (d *DeploymentServiceDescriptor) GetApiName() string {
	return "DeploymentService"
}

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

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

func GetDeploymentServiceDescriptor() *DeploymentServiceDescriptor {
	return deploymentServiceDescriptor
}

func initDescriptors() {
	deploymentServiceDescriptor = &DeploymentServiceDescriptor{}
	getDeploymentDescriptor = &GetDeploymentDescriptor{}
	batchGetDeploymentsDescriptor = &BatchGetDeploymentsDescriptor{}
	listDeploymentsDescriptor = &ListDeploymentsDescriptor{}
	watchDeploymentDescriptor = &WatchDeploymentDescriptor{}
	watchDeploymentsDescriptor = &WatchDeploymentsDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(deploymentServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getDeploymentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetDeploymentsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listDeploymentsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchDeploymentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchDeploymentsDescriptor)
}

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