accepted_plan_service.pb.descriptors.go

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

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

var (
	descriptorsInitialized          bool
	acceptedPlanServiceDescriptor   *AcceptedPlanServiceDescriptor
	getAcceptedPlanDescriptor       *GetAcceptedPlanDescriptor
	batchGetAcceptedPlansDescriptor *BatchGetAcceptedPlansDescriptor
	listAcceptedPlansDescriptor     *ListAcceptedPlansDescriptor
	watchAcceptedPlanDescriptor     *WatchAcceptedPlanDescriptor
	watchAcceptedPlansDescriptor    *WatchAcceptedPlansDescriptor
	createAcceptedPlanDescriptor    *CreateAcceptedPlanDescriptor
	updateAcceptedPlanDescriptor    *UpdateAcceptedPlanDescriptor
	deleteAcceptedPlanDescriptor    *DeleteAcceptedPlanDescriptor
)

type GetAcceptedPlanDescriptor struct{}

type GetAcceptedPlanDescriptorClientMsgHandle struct{}

type GetAcceptedPlanDescriptorServerMsgHandle struct{}

func (d *GetAcceptedPlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetAcceptedPlanRequest{}
}

func (d *GetAcceptedPlanDescriptor) NewEmptyServerMsg() proto.Message {
	return &accepted_plan.AcceptedPlan{}
}

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

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

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

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

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

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

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

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

func (d *GetAcceptedPlanDescriptor) GetMethodName() string {
	return "GetAcceptedPlan"
}

func (d *GetAcceptedPlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.AcceptedPlanService/GetAcceptedPlan"
}

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

func (d *GetAcceptedPlanDescriptor) GetApiName() string {
	return "AcceptedPlanService"
}

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

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

func (d *GetAcceptedPlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return acceptedPlanServiceDescriptor
}

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

func (d *GetAcceptedPlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetAcceptedPlanDescriptorClientMsgHandle{}
}

func (d *GetAcceptedPlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetAcceptedPlanDescriptorServerMsgHandle{}
}

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

func (h *GetAcceptedPlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetAcceptedPlanRequest) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetAcceptedPlanRequest) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetAcceptedPlanRequest) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetAcceptedPlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*accepted_plan.AcceptedPlan)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*accepted_plan.AcceptedPlan) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetAcceptedPlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*accepted_plan.AcceptedPlan)
}

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

func GetGetAcceptedPlanDescriptor() *GetAcceptedPlanDescriptor {
	return getAcceptedPlanDescriptor
}

type BatchGetAcceptedPlansDescriptor struct{}

type BatchGetAcceptedPlansDescriptorClientMsgHandle struct{}

type BatchGetAcceptedPlansDescriptorServerMsgHandle struct{}

func (d *BatchGetAcceptedPlansDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetAcceptedPlansRequest{}
}

func (d *BatchGetAcceptedPlansDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetAcceptedPlansResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetAcceptedPlansDescriptor) GetMethodName() string {
	return "BatchGetAcceptedPlans"
}

func (d *BatchGetAcceptedPlansDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.AcceptedPlanService/BatchGetAcceptedPlans"
}

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

func (d *BatchGetAcceptedPlansDescriptor) GetApiName() string {
	return "AcceptedPlanService"
}

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

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

func (d *BatchGetAcceptedPlansDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return acceptedPlanServiceDescriptor
}

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

func (d *BatchGetAcceptedPlansDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetAcceptedPlansDescriptorClientMsgHandle{}
}

func (d *BatchGetAcceptedPlansDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetAcceptedPlansDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetAcceptedPlansDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetAcceptedPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetAcceptedPlansRequest) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetAcceptedPlansDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetAcceptedPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetAcceptedPlansRequest) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetAcceptedPlansDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetAcceptedPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetAcceptedPlansResponse) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetAcceptedPlansDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetAcceptedPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetAcceptedPlansResponse) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAcceptedPlans(); len(resources) > 0 {
			return accepted_plan.AcceptedPlanList(resources)
		}
	}
	return (accepted_plan.AcceptedPlanList)(nil)
}

func GetBatchGetAcceptedPlansDescriptor() *BatchGetAcceptedPlansDescriptor {
	return batchGetAcceptedPlansDescriptor
}

type ListAcceptedPlansDescriptor struct{}

type ListAcceptedPlansDescriptorClientMsgHandle struct{}

type ListAcceptedPlansDescriptorServerMsgHandle struct{}

func (d *ListAcceptedPlansDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListAcceptedPlansRequest{}
}

func (d *ListAcceptedPlansDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListAcceptedPlansResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListAcceptedPlansDescriptor) GetMethodName() string {
	return "ListAcceptedPlans"
}

func (d *ListAcceptedPlansDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.AcceptedPlanService/ListAcceptedPlans"
}

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

func (d *ListAcceptedPlansDescriptor) GetApiName() string {
	return "AcceptedPlanService"
}

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

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

func (d *ListAcceptedPlansDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return acceptedPlanServiceDescriptor
}

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

func (d *ListAcceptedPlansDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListAcceptedPlansDescriptorClientMsgHandle{}
}

func (d *ListAcceptedPlansDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListAcceptedPlansDescriptorServerMsgHandle{}
}

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

func (h *ListAcceptedPlansDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListAcceptedPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListAcceptedPlansRequest) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListAcceptedPlansDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListAcceptedPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListAcceptedPlansRequest) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListAcceptedPlansDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListAcceptedPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListAcceptedPlansRequest) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListAcceptedPlansDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListAcceptedPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListAcceptedPlansResponse) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListAcceptedPlansDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListAcceptedPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListAcceptedPlansResponse) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetAcceptedPlans(); len(resources) > 0 {
			return accepted_plan.AcceptedPlanList(resources)
		}
	}
	return (accepted_plan.AcceptedPlanList)(nil)
}

func GetListAcceptedPlansDescriptor() *ListAcceptedPlansDescriptor {
	return listAcceptedPlansDescriptor
}

type WatchAcceptedPlanDescriptor struct{}

type WatchAcceptedPlanDescriptorClientMsgHandle struct{}

type WatchAcceptedPlanDescriptorServerMsgHandle struct{}

func (d *WatchAcceptedPlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchAcceptedPlanRequest{}
}

func (d *WatchAcceptedPlanDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchAcceptedPlanResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchAcceptedPlanDescriptor) GetMethodName() string {
	return "WatchAcceptedPlan"
}

func (d *WatchAcceptedPlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.AcceptedPlanService/WatchAcceptedPlan"
}

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

func (d *WatchAcceptedPlanDescriptor) GetApiName() string {
	return "AcceptedPlanService"
}

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

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

func (d *WatchAcceptedPlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return acceptedPlanServiceDescriptor
}

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

func (d *WatchAcceptedPlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAcceptedPlanDescriptorClientMsgHandle{}
}

func (d *WatchAcceptedPlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAcceptedPlanDescriptorServerMsgHandle{}
}

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

func (h *WatchAcceptedPlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAcceptedPlanRequest) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAcceptedPlanRequest) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAcceptedPlanRequest) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchAcceptedPlanDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchAcceptedPlanResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchAcceptedPlanResponse) *accepted_plan.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *accepted_plan.AcceptedPlanChange_Added_:
				return tResChange.Added.GetAcceptedPlan().GetName()
			case *accepted_plan.AcceptedPlanChange_Modified_:
				return tResChange.Modified.GetName()
			case *accepted_plan.AcceptedPlanChange_Removed_:
				return tResChange.Removed.GetName()
			case *accepted_plan.AcceptedPlanChange_Current_:
				return tResChange.Current.GetAcceptedPlan().GetName()
			}
		}
	}
	return (*accepted_plan.Name)(nil)
}

func (h *WatchAcceptedPlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAcceptedPlanResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAcceptedPlanResponse) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchAcceptedPlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAcceptedPlanResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAcceptedPlanResponse) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *accepted_plan.AcceptedPlanChange_Added_:
				return tResChange.Added.GetAcceptedPlan()
			case *accepted_plan.AcceptedPlanChange_Modified_:
				return tResChange.Modified.GetAcceptedPlan()
			case *accepted_plan.AcceptedPlanChange_Current_:
				return tResChange.Current.GetAcceptedPlan()
			}
		}
	}
	return (*accepted_plan.AcceptedPlan)(nil)
}

func (h *WatchAcceptedPlanDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAcceptedPlanResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAcceptedPlanResponse) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchAcceptedPlanDescriptor() *WatchAcceptedPlanDescriptor {
	return watchAcceptedPlanDescriptor
}

type WatchAcceptedPlansDescriptor struct{}

type WatchAcceptedPlansDescriptorClientMsgHandle struct{}

type WatchAcceptedPlansDescriptorServerMsgHandle struct{}

func (d *WatchAcceptedPlansDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchAcceptedPlansRequest{}
}

func (d *WatchAcceptedPlansDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchAcceptedPlansResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchAcceptedPlansDescriptor) GetMethodName() string {
	return "WatchAcceptedPlans"
}

func (d *WatchAcceptedPlansDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.AcceptedPlanService/WatchAcceptedPlans"
}

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

func (d *WatchAcceptedPlansDescriptor) GetApiName() string {
	return "AcceptedPlanService"
}

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

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

func (d *WatchAcceptedPlansDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return acceptedPlanServiceDescriptor
}

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

func (d *WatchAcceptedPlansDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAcceptedPlansDescriptorClientMsgHandle{}
}

func (d *WatchAcceptedPlansDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchAcceptedPlansDescriptorServerMsgHandle{}
}

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

func (h *WatchAcceptedPlansDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAcceptedPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAcceptedPlansRequest) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchAcceptedPlansDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAcceptedPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAcceptedPlansRequest) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAcceptedPlansDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAcceptedPlansRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAcceptedPlansRequest) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchAcceptedPlansDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchAcceptedPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchAcceptedPlansResponse) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetAcceptedPlanChanges(); len(resChanges) > 0 {
			list := make(accepted_plan.AcceptedPlanNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *accepted_plan.AcceptedPlanChange_Added_:
					list = append(list, tResChange.Added.GetAcceptedPlan().GetName())
				case *accepted_plan.AcceptedPlanChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *accepted_plan.AcceptedPlanChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *accepted_plan.AcceptedPlanChange_Current_:
					list = append(list, tResChange.Current.GetAcceptedPlan().GetName())
				}
			}
			return list
		}
	}
	return (accepted_plan.AcceptedPlanNameList)(nil)
}

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

func (h *WatchAcceptedPlansDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchAcceptedPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchAcceptedPlansResponse) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchAcceptedPlansDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchAcceptedPlansResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchAcceptedPlansResponse) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetAcceptedPlanChanges(); len(resChanges) > 0 {
			list := make(accepted_plan.AcceptedPlanList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *accepted_plan.AcceptedPlanChange_Added_:
					list = append(list, tResChange.Added.GetAcceptedPlan())
				case *accepted_plan.AcceptedPlanChange_Modified_:
					list = append(list, tResChange.Modified.GetAcceptedPlan())
				case *accepted_plan.AcceptedPlanChange_Current_:
					list = append(list, tResChange.Current.GetAcceptedPlan())
				}
			}
			return list
		}
	}
	return (accepted_plan.AcceptedPlanList)(nil)
}

func GetWatchAcceptedPlansDescriptor() *WatchAcceptedPlansDescriptor {
	return watchAcceptedPlansDescriptor
}

type CreateAcceptedPlanDescriptor struct{}

type CreateAcceptedPlanDescriptorClientMsgHandle struct{}

type CreateAcceptedPlanDescriptorServerMsgHandle struct{}

func (d *CreateAcceptedPlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateAcceptedPlanRequest{}
}

func (d *CreateAcceptedPlanDescriptor) NewEmptyServerMsg() proto.Message {
	return &accepted_plan.AcceptedPlan{}
}

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

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

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

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

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

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

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

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

func (d *CreateAcceptedPlanDescriptor) GetMethodName() string {
	return "CreateAcceptedPlan"
}

func (d *CreateAcceptedPlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.AcceptedPlanService/CreateAcceptedPlan"
}

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

func (d *CreateAcceptedPlanDescriptor) GetApiName() string {
	return "AcceptedPlanService"
}

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

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

func (d *CreateAcceptedPlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return acceptedPlanServiceDescriptor
}

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

func (d *CreateAcceptedPlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateAcceptedPlanDescriptorClientMsgHandle{}
}

func (d *CreateAcceptedPlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateAcceptedPlanDescriptorServerMsgHandle{}
}

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

func (h *CreateAcceptedPlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateAcceptedPlanRequest) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateAcceptedPlanRequest) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetAcceptedPlan()
	}
	return (*accepted_plan.AcceptedPlan)(nil)
}

func (h *CreateAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateAcceptedPlanRequest) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateAcceptedPlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*accepted_plan.AcceptedPlan)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*accepted_plan.AcceptedPlan) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateAcceptedPlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*accepted_plan.AcceptedPlan)
}

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

func GetCreateAcceptedPlanDescriptor() *CreateAcceptedPlanDescriptor {
	return createAcceptedPlanDescriptor
}

type UpdateAcceptedPlanDescriptor struct{}

type UpdateAcceptedPlanDescriptorClientMsgHandle struct{}

type UpdateAcceptedPlanDescriptorServerMsgHandle struct{}

func (d *UpdateAcceptedPlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateAcceptedPlanRequest{}
}

func (d *UpdateAcceptedPlanDescriptor) NewEmptyServerMsg() proto.Message {
	return &accepted_plan.AcceptedPlan{}
}

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

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

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

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

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

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

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

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

func (d *UpdateAcceptedPlanDescriptor) GetMethodName() string {
	return "UpdateAcceptedPlan"
}

func (d *UpdateAcceptedPlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.AcceptedPlanService/UpdateAcceptedPlan"
}

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

func (d *UpdateAcceptedPlanDescriptor) GetApiName() string {
	return "AcceptedPlanService"
}

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

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

func (d *UpdateAcceptedPlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return acceptedPlanServiceDescriptor
}

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

func (d *UpdateAcceptedPlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateAcceptedPlanDescriptorClientMsgHandle{}
}

func (d *UpdateAcceptedPlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateAcceptedPlanDescriptorServerMsgHandle{}
}

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

func (h *UpdateAcceptedPlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateAcceptedPlanRequest) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateAcceptedPlanRequest) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetAcceptedPlan()
	}
	return (*accepted_plan.AcceptedPlan)(nil)
}

func (h *UpdateAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateAcceptedPlanRequest) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateAcceptedPlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*accepted_plan.AcceptedPlan)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*accepted_plan.AcceptedPlan) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateAcceptedPlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*accepted_plan.AcceptedPlan)
}

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

func GetUpdateAcceptedPlanDescriptor() *UpdateAcceptedPlanDescriptor {
	return updateAcceptedPlanDescriptor
}

type DeleteAcceptedPlanDescriptor struct{}

type DeleteAcceptedPlanDescriptorClientMsgHandle struct{}

type DeleteAcceptedPlanDescriptorServerMsgHandle struct{}

func (d *DeleteAcceptedPlanDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteAcceptedPlanRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteAcceptedPlanDescriptor) GetMethodName() string {
	return "DeleteAcceptedPlan"
}

func (d *DeleteAcceptedPlanDescriptor) GetFullMethodName() string {
	return "/ntt.limits.v1.AcceptedPlanService/DeleteAcceptedPlan"
}

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

func (d *DeleteAcceptedPlanDescriptor) GetApiName() string {
	return "AcceptedPlanService"
}

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

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

func (d *DeleteAcceptedPlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return acceptedPlanServiceDescriptor
}

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

func (d *DeleteAcceptedPlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteAcceptedPlanDescriptorClientMsgHandle{}
}

func (d *DeleteAcceptedPlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteAcceptedPlanDescriptorServerMsgHandle{}
}

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

func (h *DeleteAcceptedPlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteAcceptedPlanRequest) []*accepted_plan.Name
	})
	if ok {
		return accepted_plan.AcceptedPlanNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteAcceptedPlanRequest) *accepted_plan.AcceptedPlan
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteAcceptedPlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteAcceptedPlanRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteAcceptedPlanRequest) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteAcceptedPlanDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*accepted_plan.AcceptedPlan
	})
	if ok {
		return accepted_plan.AcceptedPlanList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteAcceptedPlanDescriptor() *DeleteAcceptedPlanDescriptor {
	return deleteAcceptedPlanDescriptor
}

type AcceptedPlanServiceDescriptor struct{}

func (d *AcceptedPlanServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getAcceptedPlanDescriptor,
		batchGetAcceptedPlansDescriptor,
		listAcceptedPlansDescriptor,
		watchAcceptedPlanDescriptor,
		watchAcceptedPlansDescriptor,
		createAcceptedPlanDescriptor,
		updateAcceptedPlanDescriptor,
		deleteAcceptedPlanDescriptor,
	}
}

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

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

func (d *AcceptedPlanServiceDescriptor) GetApiName() string {
	return "AcceptedPlanService"
}

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

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

func GetAcceptedPlanServiceDescriptor() *AcceptedPlanServiceDescriptor {
	return acceptedPlanServiceDescriptor
}

func initDescriptors() {
	acceptedPlanServiceDescriptor = &AcceptedPlanServiceDescriptor{}
	getAcceptedPlanDescriptor = &GetAcceptedPlanDescriptor{}
	batchGetAcceptedPlansDescriptor = &BatchGetAcceptedPlansDescriptor{}
	listAcceptedPlansDescriptor = &ListAcceptedPlansDescriptor{}
	watchAcceptedPlanDescriptor = &WatchAcceptedPlanDescriptor{}
	watchAcceptedPlansDescriptor = &WatchAcceptedPlansDescriptor{}
	createAcceptedPlanDescriptor = &CreateAcceptedPlanDescriptor{}
	updateAcceptedPlanDescriptor = &UpdateAcceptedPlanDescriptor{}
	deleteAcceptedPlanDescriptor = &DeleteAcceptedPlanDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(acceptedPlanServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getAcceptedPlanDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetAcceptedPlansDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listAcceptedPlansDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchAcceptedPlanDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchAcceptedPlansDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createAcceptedPlanDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateAcceptedPlanDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteAcceptedPlanDescriptor)
}

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