plan_assignment_service.pb.descriptors.go

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

package plan_assignment_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 (
	plan_assignment "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/plan_assignment"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// 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 (
	_ = &plan_assignment.PlanAssignment{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized            bool
	planAssignmentServiceDescriptor   *PlanAssignmentServiceDescriptor
	getPlanAssignmentDescriptor       *GetPlanAssignmentDescriptor
	batchGetPlanAssignmentsDescriptor *BatchGetPlanAssignmentsDescriptor
	listPlanAssignmentsDescriptor     *ListPlanAssignmentsDescriptor
	watchPlanAssignmentDescriptor     *WatchPlanAssignmentDescriptor
	watchPlanAssignmentsDescriptor    *WatchPlanAssignmentsDescriptor
	createPlanAssignmentDescriptor    *CreatePlanAssignmentDescriptor
	updatePlanAssignmentDescriptor    *UpdatePlanAssignmentDescriptor
	deletePlanAssignmentDescriptor    *DeletePlanAssignmentDescriptor
	migratePlanAssignmentDescriptor   *MigratePlanAssignmentDescriptor
)

type GetPlanAssignmentDescriptor struct{}

type GetPlanAssignmentDescriptorClientMsgHandle struct{}

type GetPlanAssignmentDescriptorServerMsgHandle struct{}

func (d *GetPlanAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetPlanAssignmentRequest{}
}

func (d *GetPlanAssignmentDescriptor) NewEmptyServerMsg() proto.Message {
	return &plan_assignment.PlanAssignment{}
}

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

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

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

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

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

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

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

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

func (d *GetPlanAssignmentDescriptor) GetMethodName() string {
	return "GetPlanAssignment"
}

func (d *GetPlanAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService/GetPlanAssignment"
}

func (d *GetPlanAssignmentDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *GetPlanAssignmentDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *GetPlanAssignmentDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func (d *GetPlanAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planAssignmentServiceDescriptor
}

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

func (d *GetPlanAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetPlanAssignmentDescriptorClientMsgHandle{}
}

func (d *GetPlanAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetPlanAssignmentDescriptorServerMsgHandle{}
}

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

func (h *GetPlanAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetPlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetPlanAssignmentRequest) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetPlanAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetPlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetPlanAssignmentRequest) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetPlanAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetPlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetPlanAssignmentRequest) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetPlanAssignmentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*plan_assignment.PlanAssignment)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*plan_assignment.PlanAssignment) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetPlanAssignmentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*plan_assignment.PlanAssignment)
}

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

func GetGetPlanAssignmentDescriptor() *GetPlanAssignmentDescriptor {
	return getPlanAssignmentDescriptor
}

type BatchGetPlanAssignmentsDescriptor struct{}

type BatchGetPlanAssignmentsDescriptorClientMsgHandle struct{}

type BatchGetPlanAssignmentsDescriptorServerMsgHandle struct{}

func (d *BatchGetPlanAssignmentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetPlanAssignmentsRequest{}
}

func (d *BatchGetPlanAssignmentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetPlanAssignmentsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetPlanAssignmentsDescriptor) GetMethodName() string {
	return "BatchGetPlanAssignments"
}

func (d *BatchGetPlanAssignmentsDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService/BatchGetPlanAssignments"
}

func (d *BatchGetPlanAssignmentsDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *BatchGetPlanAssignmentsDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *BatchGetPlanAssignmentsDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func (d *BatchGetPlanAssignmentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planAssignmentServiceDescriptor
}

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

func (d *BatchGetPlanAssignmentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetPlanAssignmentsDescriptorClientMsgHandle{}
}

func (d *BatchGetPlanAssignmentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetPlanAssignmentsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetPlanAssignmentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetPlanAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetPlanAssignmentsRequest) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetPlanAssignmentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetPlanAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetPlanAssignmentsRequest) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetPlanAssignmentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetPlanAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetPlanAssignmentsResponse) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetPlanAssignmentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetPlanAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetPlanAssignmentsResponse) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetPlanAssignments(); len(resources) > 0 {
			return plan_assignment.PlanAssignmentList(resources)
		}
	}
	return (plan_assignment.PlanAssignmentList)(nil)
}

func GetBatchGetPlanAssignmentsDescriptor() *BatchGetPlanAssignmentsDescriptor {
	return batchGetPlanAssignmentsDescriptor
}

type ListPlanAssignmentsDescriptor struct{}

type ListPlanAssignmentsDescriptorClientMsgHandle struct{}

type ListPlanAssignmentsDescriptorServerMsgHandle struct{}

func (d *ListPlanAssignmentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListPlanAssignmentsRequest{}
}

func (d *ListPlanAssignmentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListPlanAssignmentsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListPlanAssignmentsDescriptor) GetMethodName() string {
	return "ListPlanAssignments"
}

func (d *ListPlanAssignmentsDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService/ListPlanAssignments"
}

func (d *ListPlanAssignmentsDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *ListPlanAssignmentsDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *ListPlanAssignmentsDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func (d *ListPlanAssignmentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planAssignmentServiceDescriptor
}

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

func (d *ListPlanAssignmentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListPlanAssignmentsDescriptorClientMsgHandle{}
}

func (d *ListPlanAssignmentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListPlanAssignmentsDescriptorServerMsgHandle{}
}

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

func (h *ListPlanAssignmentsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListPlanAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListPlanAssignmentsRequest) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListPlanAssignmentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListPlanAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListPlanAssignmentsRequest) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListPlanAssignmentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListPlanAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListPlanAssignmentsRequest) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListPlanAssignmentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListPlanAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListPlanAssignmentsResponse) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListPlanAssignmentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListPlanAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListPlanAssignmentsResponse) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetPlanAssignments(); len(resources) > 0 {
			return plan_assignment.PlanAssignmentList(resources)
		}
	}
	return (plan_assignment.PlanAssignmentList)(nil)
}

func GetListPlanAssignmentsDescriptor() *ListPlanAssignmentsDescriptor {
	return listPlanAssignmentsDescriptor
}

type WatchPlanAssignmentDescriptor struct{}

type WatchPlanAssignmentDescriptorClientMsgHandle struct{}

type WatchPlanAssignmentDescriptorServerMsgHandle struct{}

func (d *WatchPlanAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchPlanAssignmentRequest{}
}

func (d *WatchPlanAssignmentDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchPlanAssignmentResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchPlanAssignmentDescriptor) GetMethodName() string {
	return "WatchPlanAssignment"
}

func (d *WatchPlanAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService/WatchPlanAssignment"
}

func (d *WatchPlanAssignmentDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *WatchPlanAssignmentDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *WatchPlanAssignmentDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func (d *WatchPlanAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planAssignmentServiceDescriptor
}

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

func (d *WatchPlanAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPlanAssignmentDescriptorClientMsgHandle{}
}

func (d *WatchPlanAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPlanAssignmentDescriptorServerMsgHandle{}
}

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

func (h *WatchPlanAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPlanAssignmentRequest) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPlanAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPlanAssignmentRequest) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchPlanAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPlanAssignmentRequest) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchPlanAssignmentDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchPlanAssignmentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchPlanAssignmentResponse) *plan_assignment.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *plan_assignment.PlanAssignmentChange_Added_:
				return tResChange.Added.GetPlanAssignment().GetName()
			case *plan_assignment.PlanAssignmentChange_Modified_:
				return tResChange.Modified.GetName()
			case *plan_assignment.PlanAssignmentChange_Removed_:
				return tResChange.Removed.GetName()
			case *plan_assignment.PlanAssignmentChange_Current_:
				return tResChange.Current.GetPlanAssignment().GetName()
			}
		}
	}
	return (*plan_assignment.Name)(nil)
}

func (h *WatchPlanAssignmentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPlanAssignmentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPlanAssignmentResponse) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPlanAssignmentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPlanAssignmentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPlanAssignmentResponse) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *plan_assignment.PlanAssignmentChange_Added_:
				return tResChange.Added.GetPlanAssignment()
			case *plan_assignment.PlanAssignmentChange_Modified_:
				return tResChange.Modified.GetPlanAssignment()
			case *plan_assignment.PlanAssignmentChange_Current_:
				return tResChange.Current.GetPlanAssignment()
			}
		}
	}
	return (*plan_assignment.PlanAssignment)(nil)
}

func (h *WatchPlanAssignmentDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPlanAssignmentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPlanAssignmentResponse) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchPlanAssignmentDescriptor() *WatchPlanAssignmentDescriptor {
	return watchPlanAssignmentDescriptor
}

type WatchPlanAssignmentsDescriptor struct{}

type WatchPlanAssignmentsDescriptorClientMsgHandle struct{}

type WatchPlanAssignmentsDescriptorServerMsgHandle struct{}

func (d *WatchPlanAssignmentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchPlanAssignmentsRequest{}
}

func (d *WatchPlanAssignmentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchPlanAssignmentsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchPlanAssignmentsDescriptor) GetMethodName() string {
	return "WatchPlanAssignments"
}

func (d *WatchPlanAssignmentsDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService/WatchPlanAssignments"
}

func (d *WatchPlanAssignmentsDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *WatchPlanAssignmentsDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *WatchPlanAssignmentsDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func (d *WatchPlanAssignmentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planAssignmentServiceDescriptor
}

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

func (d *WatchPlanAssignmentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPlanAssignmentsDescriptorClientMsgHandle{}
}

func (d *WatchPlanAssignmentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPlanAssignmentsDescriptorServerMsgHandle{}
}

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

func (h *WatchPlanAssignmentsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPlanAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPlanAssignmentsRequest) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPlanAssignmentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPlanAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPlanAssignmentsRequest) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchPlanAssignmentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPlanAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPlanAssignmentsRequest) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchPlanAssignmentsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPlanAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPlanAssignmentsResponse) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetPlanAssignmentChanges(); len(resChanges) > 0 {
			list := make(plan_assignment.PlanAssignmentNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *plan_assignment.PlanAssignmentChange_Added_:
					list = append(list, tResChange.Added.GetPlanAssignment().GetName())
				case *plan_assignment.PlanAssignmentChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *plan_assignment.PlanAssignmentChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *plan_assignment.PlanAssignmentChange_Current_:
					list = append(list, tResChange.Current.GetPlanAssignment().GetName())
				}
			}
			return list
		}
	}
	return (plan_assignment.PlanAssignmentNameList)(nil)
}

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

func (h *WatchPlanAssignmentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPlanAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPlanAssignmentsResponse) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchPlanAssignmentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPlanAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPlanAssignmentsResponse) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetPlanAssignmentChanges(); len(resChanges) > 0 {
			list := make(plan_assignment.PlanAssignmentList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *plan_assignment.PlanAssignmentChange_Added_:
					list = append(list, tResChange.Added.GetPlanAssignment())
				case *plan_assignment.PlanAssignmentChange_Modified_:
					list = append(list, tResChange.Modified.GetPlanAssignment())
				case *plan_assignment.PlanAssignmentChange_Current_:
					list = append(list, tResChange.Current.GetPlanAssignment())
				}
			}
			return list
		}
	}
	return (plan_assignment.PlanAssignmentList)(nil)
}

func GetWatchPlanAssignmentsDescriptor() *WatchPlanAssignmentsDescriptor {
	return watchPlanAssignmentsDescriptor
}

type CreatePlanAssignmentDescriptor struct{}

type CreatePlanAssignmentDescriptorClientMsgHandle struct{}

type CreatePlanAssignmentDescriptorServerMsgHandle struct{}

func (d *CreatePlanAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreatePlanAssignmentRequest{}
}

func (d *CreatePlanAssignmentDescriptor) NewEmptyServerMsg() proto.Message {
	return &plan_assignment.PlanAssignment{}
}

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

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

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

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

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

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

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

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

func (d *CreatePlanAssignmentDescriptor) GetMethodName() string {
	return "CreatePlanAssignment"
}

func (d *CreatePlanAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService/CreatePlanAssignment"
}

func (d *CreatePlanAssignmentDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *CreatePlanAssignmentDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *CreatePlanAssignmentDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func (d *CreatePlanAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planAssignmentServiceDescriptor
}

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

func (d *CreatePlanAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreatePlanAssignmentDescriptorClientMsgHandle{}
}

func (d *CreatePlanAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreatePlanAssignmentDescriptorServerMsgHandle{}
}

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

func (h *CreatePlanAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreatePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreatePlanAssignmentRequest) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreatePlanAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreatePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreatePlanAssignmentRequest) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetPlanAssignment()
	}
	return (*plan_assignment.PlanAssignment)(nil)
}

func (h *CreatePlanAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreatePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreatePlanAssignmentRequest) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreatePlanAssignmentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*plan_assignment.PlanAssignment)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*plan_assignment.PlanAssignment) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreatePlanAssignmentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*plan_assignment.PlanAssignment)
}

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

func GetCreatePlanAssignmentDescriptor() *CreatePlanAssignmentDescriptor {
	return createPlanAssignmentDescriptor
}

type UpdatePlanAssignmentDescriptor struct{}

type UpdatePlanAssignmentDescriptorClientMsgHandle struct{}

type UpdatePlanAssignmentDescriptorServerMsgHandle struct{}

func (d *UpdatePlanAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdatePlanAssignmentRequest{}
}

func (d *UpdatePlanAssignmentDescriptor) NewEmptyServerMsg() proto.Message {
	return &plan_assignment.PlanAssignment{}
}

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

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

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

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

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

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

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

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

func (d *UpdatePlanAssignmentDescriptor) GetMethodName() string {
	return "UpdatePlanAssignment"
}

func (d *UpdatePlanAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService/UpdatePlanAssignment"
}

func (d *UpdatePlanAssignmentDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *UpdatePlanAssignmentDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *UpdatePlanAssignmentDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func (d *UpdatePlanAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planAssignmentServiceDescriptor
}

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

func (d *UpdatePlanAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdatePlanAssignmentDescriptorClientMsgHandle{}
}

func (d *UpdatePlanAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdatePlanAssignmentDescriptorServerMsgHandle{}
}

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

func (h *UpdatePlanAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdatePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdatePlanAssignmentRequest) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdatePlanAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdatePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdatePlanAssignmentRequest) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetPlanAssignment()
	}
	return (*plan_assignment.PlanAssignment)(nil)
}

func (h *UpdatePlanAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdatePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdatePlanAssignmentRequest) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdatePlanAssignmentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*plan_assignment.PlanAssignment)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*plan_assignment.PlanAssignment) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdatePlanAssignmentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*plan_assignment.PlanAssignment)
}

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

func GetUpdatePlanAssignmentDescriptor() *UpdatePlanAssignmentDescriptor {
	return updatePlanAssignmentDescriptor
}

type DeletePlanAssignmentDescriptor struct{}

type DeletePlanAssignmentDescriptorClientMsgHandle struct{}

type DeletePlanAssignmentDescriptorServerMsgHandle struct{}

func (d *DeletePlanAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeletePlanAssignmentRequest{}
}

func (d *DeletePlanAssignmentDescriptor) NewEmptyServerMsg() proto.Message {
	return &emptypb.Empty{}
}

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

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

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

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

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

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

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

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

func (d *DeletePlanAssignmentDescriptor) GetMethodName() string {
	return "DeletePlanAssignment"
}

func (d *DeletePlanAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService/DeletePlanAssignment"
}

func (d *DeletePlanAssignmentDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *DeletePlanAssignmentDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *DeletePlanAssignmentDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func (d *DeletePlanAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planAssignmentServiceDescriptor
}

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

func (d *DeletePlanAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeletePlanAssignmentDescriptorClientMsgHandle{}
}

func (d *DeletePlanAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeletePlanAssignmentDescriptorServerMsgHandle{}
}

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

func (h *DeletePlanAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeletePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeletePlanAssignmentRequest) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeletePlanAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeletePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeletePlanAssignmentRequest) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeletePlanAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeletePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeletePlanAssignmentRequest) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *DeletePlanAssignmentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*emptypb.Empty) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeletePlanAssignmentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*emptypb.Empty) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeletePlanAssignmentDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeletePlanAssignmentDescriptor() *DeletePlanAssignmentDescriptor {
	return deletePlanAssignmentDescriptor
}

type MigratePlanAssignmentDescriptor struct{}

type MigratePlanAssignmentDescriptorClientMsgHandle struct{}

type MigratePlanAssignmentDescriptorServerMsgHandle struct{}

func (d *MigratePlanAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &MigratePlanAssignmentRequest{}
}

func (d *MigratePlanAssignmentDescriptor) NewEmptyServerMsg() proto.Message {
	return &plan_assignment.PlanAssignment{}
}

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

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

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

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

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

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

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

func (d *MigratePlanAssignmentDescriptor) GetVerb() string {
	return "migrate"
}

func (d *MigratePlanAssignmentDescriptor) GetMethodName() string {
	return "MigratePlanAssignment"
}

func (d *MigratePlanAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService/MigratePlanAssignment"
}

func (d *MigratePlanAssignmentDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *MigratePlanAssignmentDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *MigratePlanAssignmentDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func (d *MigratePlanAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planAssignmentServiceDescriptor
}

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

func (d *MigratePlanAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &MigratePlanAssignmentDescriptorClientMsgHandle{}
}

func (d *MigratePlanAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &MigratePlanAssignmentDescriptorServerMsgHandle{}
}

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

func (h *MigratePlanAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*MigratePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*MigratePlanAssignmentRequest) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *MigratePlanAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*MigratePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*MigratePlanAssignmentRequest) *plan_assignment.PlanAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetPlanAssignment()
	}
	return (*plan_assignment.PlanAssignment)(nil)
}

func (h *MigratePlanAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*MigratePlanAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*MigratePlanAssignmentRequest) []*plan_assignment.PlanAssignment
	})
	if ok {
		return plan_assignment.PlanAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *MigratePlanAssignmentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*plan_assignment.PlanAssignment)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*plan_assignment.PlanAssignment) []*plan_assignment.Name
	})
	if ok {
		return plan_assignment.PlanAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *MigratePlanAssignmentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*plan_assignment.PlanAssignment)
}

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

func GetMigratePlanAssignmentDescriptor() *MigratePlanAssignmentDescriptor {
	return migratePlanAssignmentDescriptor
}

type PlanAssignmentServiceDescriptor struct{}

func (d *PlanAssignmentServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getPlanAssignmentDescriptor,
		batchGetPlanAssignmentsDescriptor,
		listPlanAssignmentsDescriptor,
		watchPlanAssignmentDescriptor,
		watchPlanAssignmentsDescriptor,
		createPlanAssignmentDescriptor,
		updatePlanAssignmentDescriptor,
		deletePlanAssignmentDescriptor,
		migratePlanAssignmentDescriptor,
	}
}

func (d *PlanAssignmentServiceDescriptor) GetFullAPIName() string {
	return "/ntt.limits.v1alpha2.PlanAssignmentService"
}

func (d *PlanAssignmentServiceDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1alpha2"
}

func (d *PlanAssignmentServiceDescriptor) GetApiName() string {
	return "PlanAssignmentService"
}

func (d *PlanAssignmentServiceDescriptor) GetServiceDomain() string {
	return "limits.edgelq.com"
}

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

func GetPlanAssignmentServiceDescriptor() *PlanAssignmentServiceDescriptor {
	return planAssignmentServiceDescriptor
}

func initDescriptors() {
	planAssignmentServiceDescriptor = &PlanAssignmentServiceDescriptor{}
	getPlanAssignmentDescriptor = &GetPlanAssignmentDescriptor{}
	batchGetPlanAssignmentsDescriptor = &BatchGetPlanAssignmentsDescriptor{}
	listPlanAssignmentsDescriptor = &ListPlanAssignmentsDescriptor{}
	watchPlanAssignmentDescriptor = &WatchPlanAssignmentDescriptor{}
	watchPlanAssignmentsDescriptor = &WatchPlanAssignmentsDescriptor{}
	createPlanAssignmentDescriptor = &CreatePlanAssignmentDescriptor{}
	updatePlanAssignmentDescriptor = &UpdatePlanAssignmentDescriptor{}
	deletePlanAssignmentDescriptor = &DeletePlanAssignmentDescriptor{}
	migratePlanAssignmentDescriptor = &MigratePlanAssignmentDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(planAssignmentServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getPlanAssignmentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetPlanAssignmentsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listPlanAssignmentsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPlanAssignmentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPlanAssignmentsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createPlanAssignmentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updatePlanAssignmentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deletePlanAssignmentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(migratePlanAssignmentDescriptor)
}

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