github.com/cloudwan/edgelq-sdk@v1.15.4/cellular-api/client/v1/sim_card/sim_card_service.pb.descriptors.go

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

package sim_card_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 (
	sim_card "github.com/cloudwan/edgelq-sdk/cellular-api/resources/v1/sim_card"
	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 (
	_ = &sim_card.SimCard{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized     bool
	simCardServiceDescriptor   *SimCardServiceDescriptor
	getSimCardDescriptor       *GetSimCardDescriptor
	batchGetSimCardsDescriptor *BatchGetSimCardsDescriptor
	listSimCardsDescriptor     *ListSimCardsDescriptor
	watchSimCardDescriptor     *WatchSimCardDescriptor
	watchSimCardsDescriptor    *WatchSimCardsDescriptor
	createSimCardDescriptor    *CreateSimCardDescriptor
	updateSimCardDescriptor    *UpdateSimCardDescriptor
	deleteSimCardDescriptor    *DeleteSimCardDescriptor
	activateDescriptor         *ActivateDescriptor
	suspendDescriptor          *SuspendDescriptor
	terminateDescriptor        *TerminateDescriptor
	reactivateDescriptor       *ReactivateDescriptor
)

type GetSimCardDescriptor struct{}

type GetSimCardDescriptorClientMsgHandle struct{}

type GetSimCardDescriptorServerMsgHandle struct{}

func (d *GetSimCardDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetSimCardRequest{}
}

func (d *GetSimCardDescriptor) NewEmptyServerMsg() proto.Message {
	return &sim_card.SimCard{}
}

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

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

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

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

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

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

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

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

func (d *GetSimCardDescriptor) GetMethodName() string {
	return "GetSimCard"
}

func (d *GetSimCardDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/GetSimCard"
}

func (d *GetSimCardDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *GetSimCardDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *GetSimCardDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *GetSimCardDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *GetSimCardDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetSimCardDescriptorClientMsgHandle{}
}

func (d *GetSimCardDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetSimCardDescriptorServerMsgHandle{}
}

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

func (h *GetSimCardDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetSimCardRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetSimCardDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetSimCardRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetSimCardDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetSimCardRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetSimCardDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*sim_card.SimCard)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*sim_card.SimCard) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetSimCardDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*sim_card.SimCard)
}

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

func GetGetSimCardDescriptor() *GetSimCardDescriptor {
	return getSimCardDescriptor
}

type BatchGetSimCardsDescriptor struct{}

type BatchGetSimCardsDescriptorClientMsgHandle struct{}

type BatchGetSimCardsDescriptorServerMsgHandle struct{}

func (d *BatchGetSimCardsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetSimCardsRequest{}
}

func (d *BatchGetSimCardsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetSimCardsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetSimCardsDescriptor) GetMethodName() string {
	return "BatchGetSimCards"
}

func (d *BatchGetSimCardsDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/BatchGetSimCards"
}

func (d *BatchGetSimCardsDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *BatchGetSimCardsDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *BatchGetSimCardsDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *BatchGetSimCardsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *BatchGetSimCardsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetSimCardsDescriptorClientMsgHandle{}
}

func (d *BatchGetSimCardsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetSimCardsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetSimCardsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetSimCardsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetSimCardsRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetSimCardsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetSimCardsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetSimCardsRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetSimCardsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetSimCardsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetSimCardsResponse) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetSimCardsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetSimCardsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetSimCardsResponse) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetSimCards(); len(resources) > 0 {
			return sim_card.SimCardList(resources)
		}
	}
	return (sim_card.SimCardList)(nil)
}

func GetBatchGetSimCardsDescriptor() *BatchGetSimCardsDescriptor {
	return batchGetSimCardsDescriptor
}

type ListSimCardsDescriptor struct{}

type ListSimCardsDescriptorClientMsgHandle struct{}

type ListSimCardsDescriptorServerMsgHandle struct{}

func (d *ListSimCardsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListSimCardsRequest{}
}

func (d *ListSimCardsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListSimCardsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListSimCardsDescriptor) GetMethodName() string {
	return "ListSimCards"
}

func (d *ListSimCardsDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/ListSimCards"
}

func (d *ListSimCardsDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *ListSimCardsDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *ListSimCardsDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *ListSimCardsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *ListSimCardsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListSimCardsDescriptorClientMsgHandle{}
}

func (d *ListSimCardsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListSimCardsDescriptorServerMsgHandle{}
}

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

func (h *ListSimCardsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListSimCardsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListSimCardsRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListSimCardsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListSimCardsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListSimCardsRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListSimCardsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListSimCardsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListSimCardsRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListSimCardsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListSimCardsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListSimCardsResponse) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListSimCardsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListSimCardsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListSimCardsResponse) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetSimCards(); len(resources) > 0 {
			return sim_card.SimCardList(resources)
		}
	}
	return (sim_card.SimCardList)(nil)
}

func GetListSimCardsDescriptor() *ListSimCardsDescriptor {
	return listSimCardsDescriptor
}

type WatchSimCardDescriptor struct{}

type WatchSimCardDescriptorClientMsgHandle struct{}

type WatchSimCardDescriptorServerMsgHandle struct{}

func (d *WatchSimCardDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchSimCardRequest{}
}

func (d *WatchSimCardDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchSimCardResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchSimCardDescriptor) GetMethodName() string {
	return "WatchSimCard"
}

func (d *WatchSimCardDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/WatchSimCard"
}

func (d *WatchSimCardDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *WatchSimCardDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *WatchSimCardDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *WatchSimCardDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *WatchSimCardDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchSimCardDescriptorClientMsgHandle{}
}

func (d *WatchSimCardDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchSimCardDescriptorServerMsgHandle{}
}

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

func (h *WatchSimCardDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchSimCardRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchSimCardDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchSimCardRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchSimCardDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchSimCardRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchSimCardDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchSimCardResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchSimCardResponse) *sim_card.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *sim_card.SimCardChange_Added_:
				return tResChange.Added.GetSimCard().GetName()
			case *sim_card.SimCardChange_Modified_:
				return tResChange.Modified.GetName()
			case *sim_card.SimCardChange_Removed_:
				return tResChange.Removed.GetName()
			case *sim_card.SimCardChange_Current_:
				return tResChange.Current.GetSimCard().GetName()
			}
		}
	}
	return (*sim_card.Name)(nil)
}

func (h *WatchSimCardDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchSimCardResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchSimCardResponse) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchSimCardDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchSimCardResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchSimCardResponse) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *sim_card.SimCardChange_Added_:
				return tResChange.Added.GetSimCard()
			case *sim_card.SimCardChange_Modified_:
				return tResChange.Modified.GetSimCard()
			case *sim_card.SimCardChange_Current_:
				return tResChange.Current.GetSimCard()
			}
		}
	}
	return (*sim_card.SimCard)(nil)
}

func (h *WatchSimCardDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchSimCardResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchSimCardResponse) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchSimCardDescriptor() *WatchSimCardDescriptor {
	return watchSimCardDescriptor
}

type WatchSimCardsDescriptor struct{}

type WatchSimCardsDescriptorClientMsgHandle struct{}

type WatchSimCardsDescriptorServerMsgHandle struct{}

func (d *WatchSimCardsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchSimCardsRequest{}
}

func (d *WatchSimCardsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchSimCardsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchSimCardsDescriptor) GetMethodName() string {
	return "WatchSimCards"
}

func (d *WatchSimCardsDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/WatchSimCards"
}

func (d *WatchSimCardsDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *WatchSimCardsDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *WatchSimCardsDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *WatchSimCardsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *WatchSimCardsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchSimCardsDescriptorClientMsgHandle{}
}

func (d *WatchSimCardsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchSimCardsDescriptorServerMsgHandle{}
}

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

func (h *WatchSimCardsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchSimCardsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchSimCardsRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchSimCardsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchSimCardsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchSimCardsRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchSimCardsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchSimCardsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchSimCardsRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchSimCardsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchSimCardsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchSimCardsResponse) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetSimCardChanges(); len(resChanges) > 0 {
			list := make(sim_card.SimCardNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *sim_card.SimCardChange_Added_:
					list = append(list, tResChange.Added.GetSimCard().GetName())
				case *sim_card.SimCardChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *sim_card.SimCardChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *sim_card.SimCardChange_Current_:
					list = append(list, tResChange.Current.GetSimCard().GetName())
				}
			}
			return list
		}
	}
	return (sim_card.SimCardNameList)(nil)
}

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

func (h *WatchSimCardsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchSimCardsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchSimCardsResponse) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchSimCardsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchSimCardsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchSimCardsResponse) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetSimCardChanges(); len(resChanges) > 0 {
			list := make(sim_card.SimCardList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *sim_card.SimCardChange_Added_:
					list = append(list, tResChange.Added.GetSimCard())
				case *sim_card.SimCardChange_Modified_:
					list = append(list, tResChange.Modified.GetSimCard())
				case *sim_card.SimCardChange_Current_:
					list = append(list, tResChange.Current.GetSimCard())
				}
			}
			return list
		}
	}
	return (sim_card.SimCardList)(nil)
}

func GetWatchSimCardsDescriptor() *WatchSimCardsDescriptor {
	return watchSimCardsDescriptor
}

type CreateSimCardDescriptor struct{}

type CreateSimCardDescriptorClientMsgHandle struct{}

type CreateSimCardDescriptorServerMsgHandle struct{}

func (d *CreateSimCardDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateSimCardRequest{}
}

func (d *CreateSimCardDescriptor) NewEmptyServerMsg() proto.Message {
	return &sim_card.SimCard{}
}

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

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

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

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

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

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

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

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

func (d *CreateSimCardDescriptor) GetMethodName() string {
	return "CreateSimCard"
}

func (d *CreateSimCardDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/CreateSimCard"
}

func (d *CreateSimCardDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *CreateSimCardDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *CreateSimCardDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *CreateSimCardDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *CreateSimCardDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateSimCardDescriptorClientMsgHandle{}
}

func (d *CreateSimCardDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateSimCardDescriptorServerMsgHandle{}
}

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

func (h *CreateSimCardDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateSimCardRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateSimCardDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateSimCardRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetSimCard()
	}
	return (*sim_card.SimCard)(nil)
}

func (h *CreateSimCardDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateSimCardRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateSimCardDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*sim_card.SimCard)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*sim_card.SimCard) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateSimCardDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*sim_card.SimCard)
}

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

func GetCreateSimCardDescriptor() *CreateSimCardDescriptor {
	return createSimCardDescriptor
}

type UpdateSimCardDescriptor struct{}

type UpdateSimCardDescriptorClientMsgHandle struct{}

type UpdateSimCardDescriptorServerMsgHandle struct{}

func (d *UpdateSimCardDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateSimCardRequest{}
}

func (d *UpdateSimCardDescriptor) NewEmptyServerMsg() proto.Message {
	return &sim_card.SimCard{}
}

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

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

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

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

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

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

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

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

func (d *UpdateSimCardDescriptor) GetMethodName() string {
	return "UpdateSimCard"
}

func (d *UpdateSimCardDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/UpdateSimCard"
}

func (d *UpdateSimCardDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *UpdateSimCardDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *UpdateSimCardDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *UpdateSimCardDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *UpdateSimCardDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateSimCardDescriptorClientMsgHandle{}
}

func (d *UpdateSimCardDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateSimCardDescriptorServerMsgHandle{}
}

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

func (h *UpdateSimCardDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateSimCardRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateSimCardDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateSimCardRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetSimCard()
	}
	return (*sim_card.SimCard)(nil)
}

func (h *UpdateSimCardDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateSimCardRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateSimCardDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*sim_card.SimCard)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*sim_card.SimCard) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateSimCardDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*sim_card.SimCard)
}

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

func GetUpdateSimCardDescriptor() *UpdateSimCardDescriptor {
	return updateSimCardDescriptor
}

type DeleteSimCardDescriptor struct{}

type DeleteSimCardDescriptorClientMsgHandle struct{}

type DeleteSimCardDescriptorServerMsgHandle struct{}

func (d *DeleteSimCardDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteSimCardRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteSimCardDescriptor) GetMethodName() string {
	return "DeleteSimCard"
}

func (d *DeleteSimCardDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/DeleteSimCard"
}

func (d *DeleteSimCardDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *DeleteSimCardDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *DeleteSimCardDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *DeleteSimCardDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *DeleteSimCardDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteSimCardDescriptorClientMsgHandle{}
}

func (d *DeleteSimCardDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteSimCardDescriptorServerMsgHandle{}
}

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

func (h *DeleteSimCardDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteSimCardRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteSimCardDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteSimCardRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteSimCardDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteSimCardRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteSimCardRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteSimCardDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteSimCardDescriptor() *DeleteSimCardDescriptor {
	return deleteSimCardDescriptor
}

type ActivateDescriptor struct{}

type ActivateDescriptorClientMsgHandle struct{}

type ActivateDescriptorServerMsgHandle struct{}

func (d *ActivateDescriptor) NewEmptyClientMsg() proto.Message {
	return &ActivateRequest{}
}

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

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

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

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

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

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

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

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

func (d *ActivateDescriptor) GetVerb() string {
	return "activate"
}

func (d *ActivateDescriptor) GetMethodName() string {
	return "Activate"
}

func (d *ActivateDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/Activate"
}

func (d *ActivateDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *ActivateDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *ActivateDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *ActivateDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *ActivateDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ActivateDescriptorClientMsgHandle{}
}

func (d *ActivateDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ActivateDescriptorServerMsgHandle{}
}

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

func (h *ActivateDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ActivateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ActivateRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ActivateDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ActivateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ActivateRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ActivateDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ActivateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ActivateRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *ActivateDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetActivateDescriptor() *ActivateDescriptor {
	return activateDescriptor
}

type SuspendDescriptor struct{}

type SuspendDescriptorClientMsgHandle struct{}

type SuspendDescriptorServerMsgHandle struct{}

func (d *SuspendDescriptor) NewEmptyClientMsg() proto.Message {
	return &SuspendRequest{}
}

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

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

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

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

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

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

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

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

func (d *SuspendDescriptor) GetVerb() string {
	return "suspend"
}

func (d *SuspendDescriptor) GetMethodName() string {
	return "Suspend"
}

func (d *SuspendDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/Suspend"
}

func (d *SuspendDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *SuspendDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *SuspendDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *SuspendDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *SuspendDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SuspendDescriptorClientMsgHandle{}
}

func (d *SuspendDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SuspendDescriptorServerMsgHandle{}
}

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

func (h *SuspendDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*SuspendRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*SuspendRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *SuspendDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SuspendRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SuspendRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SuspendDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SuspendRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SuspendRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *SuspendDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetSuspendDescriptor() *SuspendDescriptor {
	return suspendDescriptor
}

type TerminateDescriptor struct{}

type TerminateDescriptorClientMsgHandle struct{}

type TerminateDescriptorServerMsgHandle struct{}

func (d *TerminateDescriptor) NewEmptyClientMsg() proto.Message {
	return &TerminateRequest{}
}

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

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

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

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

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

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

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

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

func (d *TerminateDescriptor) GetVerb() string {
	return "terminate"
}

func (d *TerminateDescriptor) GetMethodName() string {
	return "Terminate"
}

func (d *TerminateDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/Terminate"
}

func (d *TerminateDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *TerminateDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *TerminateDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *TerminateDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *TerminateDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &TerminateDescriptorClientMsgHandle{}
}

func (d *TerminateDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &TerminateDescriptorServerMsgHandle{}
}

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

func (h *TerminateDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*TerminateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*TerminateRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *TerminateDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*TerminateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*TerminateRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *TerminateDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*TerminateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*TerminateRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *TerminateDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetTerminateDescriptor() *TerminateDescriptor {
	return terminateDescriptor
}

type ReactivateDescriptor struct{}

type ReactivateDescriptorClientMsgHandle struct{}

type ReactivateDescriptorServerMsgHandle struct{}

func (d *ReactivateDescriptor) NewEmptyClientMsg() proto.Message {
	return &ReactivateRequest{}
}

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

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

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

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

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

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

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

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

func (d *ReactivateDescriptor) GetVerb() string {
	return "reactivate"
}

func (d *ReactivateDescriptor) GetMethodName() string {
	return "Reactivate"
}

func (d *ReactivateDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardService/Reactivate"
}

func (d *ReactivateDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *ReactivateDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *ReactivateDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func (d *ReactivateDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardServiceDescriptor
}

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

func (d *ReactivateDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ReactivateDescriptorClientMsgHandle{}
}

func (d *ReactivateDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ReactivateDescriptorServerMsgHandle{}
}

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

func (h *ReactivateDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ReactivateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ReactivateRequest) []*sim_card.Name
	})
	if ok {
		return sim_card.SimCardNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ReactivateDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ReactivateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ReactivateRequest) *sim_card.SimCard
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ReactivateDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ReactivateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ReactivateRequest) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *ReactivateDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*sim_card.SimCard
	})
	if ok {
		return sim_card.SimCardList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetReactivateDescriptor() *ReactivateDescriptor {
	return reactivateDescriptor
}

type SimCardServiceDescriptor struct{}

func (d *SimCardServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getSimCardDescriptor,
		batchGetSimCardsDescriptor,
		listSimCardsDescriptor,
		watchSimCardDescriptor,
		watchSimCardsDescriptor,
		createSimCardDescriptor,
		updateSimCardDescriptor,
		deleteSimCardDescriptor,
		activateDescriptor,
		suspendDescriptor,
		terminateDescriptor,
		reactivateDescriptor,
	}
}

func (d *SimCardServiceDescriptor) GetFullAPIName() string {
	return "/ntt.cellular_api.v1.SimCardService"
}

func (d *SimCardServiceDescriptor) GetProtoPkgName() string {
	return "ntt.cellular_api.v1"
}

func (d *SimCardServiceDescriptor) GetApiName() string {
	return "SimCardService"
}

func (d *SimCardServiceDescriptor) GetServiceDomain() string {
	return "cellular-api.edgelq.com"
}

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

func GetSimCardServiceDescriptor() *SimCardServiceDescriptor {
	return simCardServiceDescriptor
}

func initDescriptors() {
	simCardServiceDescriptor = &SimCardServiceDescriptor{}
	getSimCardDescriptor = &GetSimCardDescriptor{}
	batchGetSimCardsDescriptor = &BatchGetSimCardsDescriptor{}
	listSimCardsDescriptor = &ListSimCardsDescriptor{}
	watchSimCardDescriptor = &WatchSimCardDescriptor{}
	watchSimCardsDescriptor = &WatchSimCardsDescriptor{}
	createSimCardDescriptor = &CreateSimCardDescriptor{}
	updateSimCardDescriptor = &UpdateSimCardDescriptor{}
	deleteSimCardDescriptor = &DeleteSimCardDescriptor{}
	activateDescriptor = &ActivateDescriptor{}
	suspendDescriptor = &SuspendDescriptor{}
	terminateDescriptor = &TerminateDescriptor{}
	reactivateDescriptor = &ReactivateDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(simCardServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getSimCardDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetSimCardsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listSimCardsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchSimCardDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchSimCardsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createSimCardDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateSimCardDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteSimCardDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(activateDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(suspendDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(terminateDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(reactivateDescriptor)
}

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