github.com/cloudwan/edgelq-sdk@v1.15.4/limits/client/v1/plan/plan_service.pb.descriptors.go

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

package plan_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 "github.com/cloudwan/edgelq-sdk/limits/resources/v1/plan"
	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.Plan{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized  bool
	planServiceDescriptor   *PlanServiceDescriptor
	getPlanDescriptor       *GetPlanDescriptor
	batchGetPlansDescriptor *BatchGetPlansDescriptor
	listPlansDescriptor     *ListPlansDescriptor
	watchPlanDescriptor     *WatchPlanDescriptor
	watchPlansDescriptor    *WatchPlansDescriptor
	createPlanDescriptor    *CreatePlanDescriptor
	updatePlanDescriptor    *UpdatePlanDescriptor
	deletePlanDescriptor    *DeletePlanDescriptor
)

type GetPlanDescriptor struct{}

type GetPlanDescriptorClientMsgHandle struct{}

type GetPlanDescriptorServerMsgHandle struct{}

func (d *GetPlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetPlanRequest{}
}

func (d *GetPlanDescriptor) NewEmptyServerMsg() proto.Message {
	return &plan.Plan{}
}

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

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

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

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

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

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

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

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

func (d *GetPlanDescriptor) GetMethodName() string {
	return "GetPlan"
}

func (d *GetPlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.PlanService/GetPlan"
}

func (d *GetPlanDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1"
}

func (d *GetPlanDescriptor) GetApiName() string {
	return "PlanService"
}

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

func (d *GetPlanDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *GetPlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planServiceDescriptor
}

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

func (d *GetPlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetPlanDescriptorClientMsgHandle{}
}

func (d *GetPlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetPlanDescriptorServerMsgHandle{}
}

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

func (h *GetPlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetPlanRequest) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetPlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetPlanRequest) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetPlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetPlanRequest) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetPlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*plan.Plan)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*plan.Plan) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetPlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*plan.Plan)
}

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

func GetGetPlanDescriptor() *GetPlanDescriptor {
	return getPlanDescriptor
}

type BatchGetPlansDescriptor struct{}

type BatchGetPlansDescriptorClientMsgHandle struct{}

type BatchGetPlansDescriptorServerMsgHandle struct{}

func (d *BatchGetPlansDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetPlansRequest{}
}

func (d *BatchGetPlansDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetPlansResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetPlansDescriptor) GetMethodName() string {
	return "BatchGetPlans"
}

func (d *BatchGetPlansDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.PlanService/BatchGetPlans"
}

func (d *BatchGetPlansDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1"
}

func (d *BatchGetPlansDescriptor) GetApiName() string {
	return "PlanService"
}

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

func (d *BatchGetPlansDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *BatchGetPlansDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planServiceDescriptor
}

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

func (d *BatchGetPlansDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetPlansDescriptorClientMsgHandle{}
}

func (d *BatchGetPlansDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetPlansDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetPlansDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetPlansRequest) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetPlansDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetPlansRequest) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetPlansDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetPlansResponse) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetPlansDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetPlansResponse) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetPlans(); len(resources) > 0 {
			return plan.PlanList(resources)
		}
	}
	return (plan.PlanList)(nil)
}

func GetBatchGetPlansDescriptor() *BatchGetPlansDescriptor {
	return batchGetPlansDescriptor
}

type ListPlansDescriptor struct{}

type ListPlansDescriptorClientMsgHandle struct{}

type ListPlansDescriptorServerMsgHandle struct{}

func (d *ListPlansDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListPlansRequest{}
}

func (d *ListPlansDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListPlansResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListPlansDescriptor) GetMethodName() string {
	return "ListPlans"
}

func (d *ListPlansDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.PlanService/ListPlans"
}

func (d *ListPlansDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1"
}

func (d *ListPlansDescriptor) GetApiName() string {
	return "PlanService"
}

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

func (d *ListPlansDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *ListPlansDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planServiceDescriptor
}

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

func (d *ListPlansDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListPlansDescriptorClientMsgHandle{}
}

func (d *ListPlansDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListPlansDescriptorServerMsgHandle{}
}

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

func (h *ListPlansDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListPlansRequest) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListPlansDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListPlansRequest) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListPlansDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListPlansRequest) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListPlansDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListPlansResponse) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListPlansDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListPlansResponse) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetPlans(); len(resources) > 0 {
			return plan.PlanList(resources)
		}
	}
	return (plan.PlanList)(nil)
}

func GetListPlansDescriptor() *ListPlansDescriptor {
	return listPlansDescriptor
}

type WatchPlanDescriptor struct{}

type WatchPlanDescriptorClientMsgHandle struct{}

type WatchPlanDescriptorServerMsgHandle struct{}

func (d *WatchPlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchPlanRequest{}
}

func (d *WatchPlanDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchPlanResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchPlanDescriptor) GetMethodName() string {
	return "WatchPlan"
}

func (d *WatchPlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.PlanService/WatchPlan"
}

func (d *WatchPlanDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1"
}

func (d *WatchPlanDescriptor) GetApiName() string {
	return "PlanService"
}

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

func (d *WatchPlanDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *WatchPlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planServiceDescriptor
}

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

func (d *WatchPlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPlanDescriptorClientMsgHandle{}
}

func (d *WatchPlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPlanDescriptorServerMsgHandle{}
}

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

func (h *WatchPlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPlanRequest) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPlanRequest) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchPlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPlanRequest) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchPlanDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchPlanResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchPlanResponse) *plan.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *plan.PlanChange_Added_:
				return tResChange.Added.GetPlan().GetName()
			case *plan.PlanChange_Modified_:
				return tResChange.Modified.GetName()
			case *plan.PlanChange_Removed_:
				return tResChange.Removed.GetName()
			case *plan.PlanChange_Current_:
				return tResChange.Current.GetPlan().GetName()
			}
		}
	}
	return (*plan.Name)(nil)
}

func (h *WatchPlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPlanResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPlanResponse) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPlanResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPlanResponse) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *plan.PlanChange_Added_:
				return tResChange.Added.GetPlan()
			case *plan.PlanChange_Modified_:
				return tResChange.Modified.GetPlan()
			case *plan.PlanChange_Current_:
				return tResChange.Current.GetPlan()
			}
		}
	}
	return (*plan.Plan)(nil)
}

func (h *WatchPlanDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPlanResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPlanResponse) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchPlanDescriptor() *WatchPlanDescriptor {
	return watchPlanDescriptor
}

type WatchPlansDescriptor struct{}

type WatchPlansDescriptorClientMsgHandle struct{}

type WatchPlansDescriptorServerMsgHandle struct{}

func (d *WatchPlansDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchPlansRequest{}
}

func (d *WatchPlansDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchPlansResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchPlansDescriptor) GetMethodName() string {
	return "WatchPlans"
}

func (d *WatchPlansDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.PlanService/WatchPlans"
}

func (d *WatchPlansDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1"
}

func (d *WatchPlansDescriptor) GetApiName() string {
	return "PlanService"
}

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

func (d *WatchPlansDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *WatchPlansDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planServiceDescriptor
}

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

func (d *WatchPlansDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPlansDescriptorClientMsgHandle{}
}

func (d *WatchPlansDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPlansDescriptorServerMsgHandle{}
}

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

func (h *WatchPlansDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPlansRequest) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPlansDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPlansRequest) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchPlansDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPlansRequest) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchPlansDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPlansResponse) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetPlanChanges(); len(resChanges) > 0 {
			list := make(plan.PlanNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *plan.PlanChange_Added_:
					list = append(list, tResChange.Added.GetPlan().GetName())
				case *plan.PlanChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *plan.PlanChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *plan.PlanChange_Current_:
					list = append(list, tResChange.Current.GetPlan().GetName())
				}
			}
			return list
		}
	}
	return (plan.PlanNameList)(nil)
}

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

func (h *WatchPlansDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPlansResponse) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchPlansDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPlansResponse) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetPlanChanges(); len(resChanges) > 0 {
			list := make(plan.PlanList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *plan.PlanChange_Added_:
					list = append(list, tResChange.Added.GetPlan())
				case *plan.PlanChange_Modified_:
					list = append(list, tResChange.Modified.GetPlan())
				case *plan.PlanChange_Current_:
					list = append(list, tResChange.Current.GetPlan())
				}
			}
			return list
		}
	}
	return (plan.PlanList)(nil)
}

func GetWatchPlansDescriptor() *WatchPlansDescriptor {
	return watchPlansDescriptor
}

type CreatePlanDescriptor struct{}

type CreatePlanDescriptorClientMsgHandle struct{}

type CreatePlanDescriptorServerMsgHandle struct{}

func (d *CreatePlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreatePlanRequest{}
}

func (d *CreatePlanDescriptor) NewEmptyServerMsg() proto.Message {
	return &plan.Plan{}
}

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

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

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

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

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

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

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

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

func (d *CreatePlanDescriptor) GetMethodName() string {
	return "CreatePlan"
}

func (d *CreatePlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.PlanService/CreatePlan"
}

func (d *CreatePlanDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1"
}

func (d *CreatePlanDescriptor) GetApiName() string {
	return "PlanService"
}

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

func (d *CreatePlanDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *CreatePlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planServiceDescriptor
}

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

func (d *CreatePlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreatePlanDescriptorClientMsgHandle{}
}

func (d *CreatePlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreatePlanDescriptorServerMsgHandle{}
}

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

func (h *CreatePlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreatePlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreatePlanRequest) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreatePlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreatePlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreatePlanRequest) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetPlan()
	}
	return (*plan.Plan)(nil)
}

func (h *CreatePlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreatePlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreatePlanRequest) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreatePlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*plan.Plan)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*plan.Plan) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreatePlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*plan.Plan)
}

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

func GetCreatePlanDescriptor() *CreatePlanDescriptor {
	return createPlanDescriptor
}

type UpdatePlanDescriptor struct{}

type UpdatePlanDescriptorClientMsgHandle struct{}

type UpdatePlanDescriptorServerMsgHandle struct{}

func (d *UpdatePlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdatePlanRequest{}
}

func (d *UpdatePlanDescriptor) NewEmptyServerMsg() proto.Message {
	return &plan.Plan{}
}

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

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

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

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

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

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

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

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

func (d *UpdatePlanDescriptor) GetMethodName() string {
	return "UpdatePlan"
}

func (d *UpdatePlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.PlanService/UpdatePlan"
}

func (d *UpdatePlanDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1"
}

func (d *UpdatePlanDescriptor) GetApiName() string {
	return "PlanService"
}

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

func (d *UpdatePlanDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *UpdatePlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planServiceDescriptor
}

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

func (d *UpdatePlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdatePlanDescriptorClientMsgHandle{}
}

func (d *UpdatePlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdatePlanDescriptorServerMsgHandle{}
}

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

func (h *UpdatePlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdatePlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdatePlanRequest) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdatePlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdatePlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdatePlanRequest) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetPlan()
	}
	return (*plan.Plan)(nil)
}

func (h *UpdatePlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdatePlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdatePlanRequest) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdatePlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*plan.Plan)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*plan.Plan) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdatePlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*plan.Plan)
}

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

func GetUpdatePlanDescriptor() *UpdatePlanDescriptor {
	return updatePlanDescriptor
}

type DeletePlanDescriptor struct{}

type DeletePlanDescriptorClientMsgHandle struct{}

type DeletePlanDescriptorServerMsgHandle struct{}

func (d *DeletePlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeletePlanRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeletePlanDescriptor) GetMethodName() string {
	return "DeletePlan"
}

func (d *DeletePlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.PlanService/DeletePlan"
}

func (d *DeletePlanDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1"
}

func (d *DeletePlanDescriptor) GetApiName() string {
	return "PlanService"
}

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

func (d *DeletePlanDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *DeletePlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return planServiceDescriptor
}

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

func (d *DeletePlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeletePlanDescriptorClientMsgHandle{}
}

func (d *DeletePlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeletePlanDescriptorServerMsgHandle{}
}

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

func (h *DeletePlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeletePlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeletePlanRequest) []*plan.Name
	})
	if ok {
		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeletePlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeletePlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeletePlanRequest) *plan.Plan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeletePlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeletePlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeletePlanRequest) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeletePlanDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*plan.Plan
	})
	if ok {
		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeletePlanDescriptor() *DeletePlanDescriptor {
	return deletePlanDescriptor
}

type PlanServiceDescriptor struct{}

func (d *PlanServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getPlanDescriptor,
		batchGetPlansDescriptor,
		listPlansDescriptor,
		watchPlanDescriptor,
		watchPlansDescriptor,
		createPlanDescriptor,
		updatePlanDescriptor,
		deletePlanDescriptor,
	}
}

func (d *PlanServiceDescriptor) GetFullAPIName() string {
	return "/ntt.limits.v1.PlanService"
}

func (d *PlanServiceDescriptor) GetProtoPkgName() string {
	return "ntt.limits.v1"
}

func (d *PlanServiceDescriptor) GetApiName() string {
	return "PlanService"
}

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

func (d *PlanServiceDescriptor) GetServiceVersion() string {
	return "v1"
}

func GetPlanServiceDescriptor() *PlanServiceDescriptor {
	return planServiceDescriptor
}

func initDescriptors() {
	planServiceDescriptor = &PlanServiceDescriptor{}
	getPlanDescriptor = &GetPlanDescriptor{}
	batchGetPlansDescriptor = &BatchGetPlansDescriptor{}
	listPlansDescriptor = &ListPlansDescriptor{}
	watchPlanDescriptor = &WatchPlanDescriptor{}
	watchPlansDescriptor = &WatchPlansDescriptor{}
	createPlanDescriptor = &CreatePlanDescriptor{}
	updatePlanDescriptor = &UpdatePlanDescriptor{}
	deletePlanDescriptor = &DeletePlanDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(planServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getPlanDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetPlansDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listPlansDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPlanDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPlansDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createPlanDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updatePlanDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deletePlanDescriptor)
}

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