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

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

package sim_card_stock_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_stock "github.com/cloudwan/edgelq-sdk/cellular-api/resources/v1/sim_card_stock"
	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_stock.SimCardStock{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized          bool
	simCardStockServiceDescriptor   *SimCardStockServiceDescriptor
	getSimCardStockDescriptor       *GetSimCardStockDescriptor
	batchGetSimCardStocksDescriptor *BatchGetSimCardStocksDescriptor
	listSimCardStocksDescriptor     *ListSimCardStocksDescriptor
	watchSimCardStockDescriptor     *WatchSimCardStockDescriptor
	watchSimCardStocksDescriptor    *WatchSimCardStocksDescriptor
	createSimCardStockDescriptor    *CreateSimCardStockDescriptor
	updateSimCardStockDescriptor    *UpdateSimCardStockDescriptor
	deleteSimCardStockDescriptor    *DeleteSimCardStockDescriptor
	allocateDescriptor              *AllocateDescriptor
	deallocateDescriptor            *DeallocateDescriptor
)

type GetSimCardStockDescriptor struct{}

type GetSimCardStockDescriptorClientMsgHandle struct{}

type GetSimCardStockDescriptorServerMsgHandle struct{}

func (d *GetSimCardStockDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetSimCardStockRequest{}
}

func (d *GetSimCardStockDescriptor) NewEmptyServerMsg() proto.Message {
	return &sim_card_stock.SimCardStock{}
}

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

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

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

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

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

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

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

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

func (d *GetSimCardStockDescriptor) GetMethodName() string {
	return "GetSimCardStock"
}

func (d *GetSimCardStockDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/GetSimCardStock"
}

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

func (d *GetSimCardStockDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *GetSimCardStockDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *GetSimCardStockDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *GetSimCardStockDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetSimCardStockDescriptorClientMsgHandle{}
}

func (d *GetSimCardStockDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetSimCardStockDescriptorServerMsgHandle{}
}

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

func (h *GetSimCardStockDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetSimCardStockRequest) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *GetSimCardStockDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *GetSimCardStockDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetSimCardStockRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetSimCardStockDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetSimCardStockRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetSimCardStockDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*sim_card_stock.SimCardStock)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*sim_card_stock.SimCardStock) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *GetSimCardStockDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *GetSimCardStockDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*sim_card_stock.SimCardStock)
}

func (h *GetSimCardStockDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*sim_card_stock.SimCardStock)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*sim_card_stock.SimCardStock) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetSimCardStockDescriptor() *GetSimCardStockDescriptor {
	return getSimCardStockDescriptor
}

type BatchGetSimCardStocksDescriptor struct{}

type BatchGetSimCardStocksDescriptorClientMsgHandle struct{}

type BatchGetSimCardStocksDescriptorServerMsgHandle struct{}

func (d *BatchGetSimCardStocksDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetSimCardStocksRequest{}
}

func (d *BatchGetSimCardStocksDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetSimCardStocksResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetSimCardStocksDescriptor) GetMethodName() string {
	return "BatchGetSimCardStocks"
}

func (d *BatchGetSimCardStocksDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/BatchGetSimCardStocks"
}

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

func (d *BatchGetSimCardStocksDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *BatchGetSimCardStocksDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *BatchGetSimCardStocksDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *BatchGetSimCardStocksDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetSimCardStocksDescriptorClientMsgHandle{}
}

func (d *BatchGetSimCardStocksDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetSimCardStocksDescriptorServerMsgHandle{}
}

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

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

func (h *BatchGetSimCardStocksDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *BatchGetSimCardStocksDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetSimCardStocksRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetSimCardStocksRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetSimCardStocksDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetSimCardStocksRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetSimCardStocksRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *BatchGetSimCardStocksDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *BatchGetSimCardStocksDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetSimCardStocksResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetSimCardStocksResponse) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetSimCardStocksDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetSimCardStocksResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetSimCardStocksResponse) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetSimCardStocks(); len(resources) > 0 {
			return sim_card_stock.SimCardStockList(resources)
		}
	}
	return (sim_card_stock.SimCardStockList)(nil)
}

func GetBatchGetSimCardStocksDescriptor() *BatchGetSimCardStocksDescriptor {
	return batchGetSimCardStocksDescriptor
}

type ListSimCardStocksDescriptor struct{}

type ListSimCardStocksDescriptorClientMsgHandle struct{}

type ListSimCardStocksDescriptorServerMsgHandle struct{}

func (d *ListSimCardStocksDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListSimCardStocksRequest{}
}

func (d *ListSimCardStocksDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListSimCardStocksResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListSimCardStocksDescriptor) GetMethodName() string {
	return "ListSimCardStocks"
}

func (d *ListSimCardStocksDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/ListSimCardStocks"
}

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

func (d *ListSimCardStocksDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *ListSimCardStocksDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *ListSimCardStocksDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *ListSimCardStocksDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListSimCardStocksDescriptorClientMsgHandle{}
}

func (d *ListSimCardStocksDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListSimCardStocksDescriptorServerMsgHandle{}
}

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

func (h *ListSimCardStocksDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListSimCardStocksRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListSimCardStocksRequest) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListSimCardStocksDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListSimCardStocksDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListSimCardStocksRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListSimCardStocksRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListSimCardStocksDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListSimCardStocksRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListSimCardStocksRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *ListSimCardStocksDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListSimCardStocksDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListSimCardStocksResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListSimCardStocksResponse) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListSimCardStocksDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListSimCardStocksResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListSimCardStocksResponse) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetSimCardStocks(); len(resources) > 0 {
			return sim_card_stock.SimCardStockList(resources)
		}
	}
	return (sim_card_stock.SimCardStockList)(nil)
}

func GetListSimCardStocksDescriptor() *ListSimCardStocksDescriptor {
	return listSimCardStocksDescriptor
}

type WatchSimCardStockDescriptor struct{}

type WatchSimCardStockDescriptorClientMsgHandle struct{}

type WatchSimCardStockDescriptorServerMsgHandle struct{}

func (d *WatchSimCardStockDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchSimCardStockRequest{}
}

func (d *WatchSimCardStockDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchSimCardStockResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchSimCardStockDescriptor) GetMethodName() string {
	return "WatchSimCardStock"
}

func (d *WatchSimCardStockDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/WatchSimCardStock"
}

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

func (d *WatchSimCardStockDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *WatchSimCardStockDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *WatchSimCardStockDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *WatchSimCardStockDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchSimCardStockDescriptorClientMsgHandle{}
}

func (d *WatchSimCardStockDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchSimCardStockDescriptorServerMsgHandle{}
}

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

func (h *WatchSimCardStockDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchSimCardStockRequest) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchSimCardStockDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchSimCardStockDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchSimCardStockRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchSimCardStockDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchSimCardStockRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchSimCardStockDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchSimCardStockResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchSimCardStockResponse) *sim_card_stock.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *sim_card_stock.SimCardStockChange_Added_:
				return tResChange.Added.GetSimCardStock().GetName()
			case *sim_card_stock.SimCardStockChange_Modified_:
				return tResChange.Modified.GetName()
			case *sim_card_stock.SimCardStockChange_Removed_:
				return tResChange.Removed.GetName()
			case *sim_card_stock.SimCardStockChange_Current_:
				return tResChange.Current.GetSimCardStock().GetName()
			}
		}
	}
	return (*sim_card_stock.Name)(nil)
}

func (h *WatchSimCardStockDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchSimCardStockResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchSimCardStockResponse) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchSimCardStockDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchSimCardStockDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchSimCardStockResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchSimCardStockResponse) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *sim_card_stock.SimCardStockChange_Added_:
				return tResChange.Added.GetSimCardStock()
			case *sim_card_stock.SimCardStockChange_Modified_:
				return tResChange.Modified.GetSimCardStock()
			case *sim_card_stock.SimCardStockChange_Current_:
				return tResChange.Current.GetSimCardStock()
			}
		}
	}
	return (*sim_card_stock.SimCardStock)(nil)
}

func (h *WatchSimCardStockDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchSimCardStockResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchSimCardStockResponse) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchSimCardStockDescriptor() *WatchSimCardStockDescriptor {
	return watchSimCardStockDescriptor
}

type WatchSimCardStocksDescriptor struct{}

type WatchSimCardStocksDescriptorClientMsgHandle struct{}

type WatchSimCardStocksDescriptorServerMsgHandle struct{}

func (d *WatchSimCardStocksDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchSimCardStocksRequest{}
}

func (d *WatchSimCardStocksDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchSimCardStocksResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchSimCardStocksDescriptor) GetMethodName() string {
	return "WatchSimCardStocks"
}

func (d *WatchSimCardStocksDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/WatchSimCardStocks"
}

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

func (d *WatchSimCardStocksDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *WatchSimCardStocksDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *WatchSimCardStocksDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *WatchSimCardStocksDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchSimCardStocksDescriptorClientMsgHandle{}
}

func (d *WatchSimCardStocksDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchSimCardStocksDescriptorServerMsgHandle{}
}

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

func (h *WatchSimCardStocksDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchSimCardStocksRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchSimCardStocksRequest) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchSimCardStocksDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchSimCardStocksDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchSimCardStocksRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchSimCardStocksRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchSimCardStocksDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchSimCardStocksRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchSimCardStocksRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchSimCardStocksDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchSimCardStocksResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchSimCardStocksResponse) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetSimCardStockChanges(); len(resChanges) > 0 {
			list := make(sim_card_stock.SimCardStockNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *sim_card_stock.SimCardStockChange_Added_:
					list = append(list, tResChange.Added.GetSimCardStock().GetName())
				case *sim_card_stock.SimCardStockChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *sim_card_stock.SimCardStockChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *sim_card_stock.SimCardStockChange_Current_:
					list = append(list, tResChange.Current.GetSimCardStock().GetName())
				}
			}
			return list
		}
	}
	return (sim_card_stock.SimCardStockNameList)(nil)
}

func (h *WatchSimCardStocksDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchSimCardStocksDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchSimCardStocksResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchSimCardStocksResponse) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchSimCardStocksDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchSimCardStocksResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchSimCardStocksResponse) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetSimCardStockChanges(); len(resChanges) > 0 {
			list := make(sim_card_stock.SimCardStockList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *sim_card_stock.SimCardStockChange_Added_:
					list = append(list, tResChange.Added.GetSimCardStock())
				case *sim_card_stock.SimCardStockChange_Modified_:
					list = append(list, tResChange.Modified.GetSimCardStock())
				case *sim_card_stock.SimCardStockChange_Current_:
					list = append(list, tResChange.Current.GetSimCardStock())
				}
			}
			return list
		}
	}
	return (sim_card_stock.SimCardStockList)(nil)
}

func GetWatchSimCardStocksDescriptor() *WatchSimCardStocksDescriptor {
	return watchSimCardStocksDescriptor
}

type CreateSimCardStockDescriptor struct{}

type CreateSimCardStockDescriptorClientMsgHandle struct{}

type CreateSimCardStockDescriptorServerMsgHandle struct{}

func (d *CreateSimCardStockDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateSimCardStockRequest{}
}

func (d *CreateSimCardStockDescriptor) NewEmptyServerMsg() proto.Message {
	return &sim_card_stock.SimCardStock{}
}

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

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

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

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

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

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

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

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

func (d *CreateSimCardStockDescriptor) GetMethodName() string {
	return "CreateSimCardStock"
}

func (d *CreateSimCardStockDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/CreateSimCardStock"
}

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

func (d *CreateSimCardStockDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *CreateSimCardStockDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *CreateSimCardStockDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *CreateSimCardStockDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateSimCardStockDescriptorClientMsgHandle{}
}

func (d *CreateSimCardStockDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateSimCardStockDescriptorServerMsgHandle{}
}

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

func (h *CreateSimCardStockDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateSimCardStockRequest) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateSimCardStockDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *CreateSimCardStockDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateSimCardStockRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetSimCardStock()
	}
	return (*sim_card_stock.SimCardStock)(nil)
}

func (h *CreateSimCardStockDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateSimCardStockRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateSimCardStockDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*sim_card_stock.SimCardStock)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*sim_card_stock.SimCardStock) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateSimCardStockDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *CreateSimCardStockDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*sim_card_stock.SimCardStock)
}

func (h *CreateSimCardStockDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*sim_card_stock.SimCardStock)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*sim_card_stock.SimCardStock) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateSimCardStockDescriptor() *CreateSimCardStockDescriptor {
	return createSimCardStockDescriptor
}

type UpdateSimCardStockDescriptor struct{}

type UpdateSimCardStockDescriptorClientMsgHandle struct{}

type UpdateSimCardStockDescriptorServerMsgHandle struct{}

func (d *UpdateSimCardStockDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateSimCardStockRequest{}
}

func (d *UpdateSimCardStockDescriptor) NewEmptyServerMsg() proto.Message {
	return &sim_card_stock.SimCardStock{}
}

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

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

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

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

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

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

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

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

func (d *UpdateSimCardStockDescriptor) GetMethodName() string {
	return "UpdateSimCardStock"
}

func (d *UpdateSimCardStockDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/UpdateSimCardStock"
}

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

func (d *UpdateSimCardStockDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *UpdateSimCardStockDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *UpdateSimCardStockDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *UpdateSimCardStockDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateSimCardStockDescriptorClientMsgHandle{}
}

func (d *UpdateSimCardStockDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateSimCardStockDescriptorServerMsgHandle{}
}

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

func (h *UpdateSimCardStockDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateSimCardStockRequest) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *UpdateSimCardStockDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *UpdateSimCardStockDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateSimCardStockRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetSimCardStock()
	}
	return (*sim_card_stock.SimCardStock)(nil)
}

func (h *UpdateSimCardStockDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateSimCardStockRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateSimCardStockDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*sim_card_stock.SimCardStock)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*sim_card_stock.SimCardStock) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *UpdateSimCardStockDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *UpdateSimCardStockDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*sim_card_stock.SimCardStock)
}

func (h *UpdateSimCardStockDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*sim_card_stock.SimCardStock)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*sim_card_stock.SimCardStock) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateSimCardStockDescriptor() *UpdateSimCardStockDescriptor {
	return updateSimCardStockDescriptor
}

type DeleteSimCardStockDescriptor struct{}

type DeleteSimCardStockDescriptorClientMsgHandle struct{}

type DeleteSimCardStockDescriptorServerMsgHandle struct{}

func (d *DeleteSimCardStockDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteSimCardStockRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteSimCardStockDescriptor) GetMethodName() string {
	return "DeleteSimCardStock"
}

func (d *DeleteSimCardStockDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/DeleteSimCardStock"
}

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

func (d *DeleteSimCardStockDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *DeleteSimCardStockDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *DeleteSimCardStockDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *DeleteSimCardStockDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteSimCardStockDescriptorClientMsgHandle{}
}

func (d *DeleteSimCardStockDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteSimCardStockDescriptorServerMsgHandle{}
}

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

func (h *DeleteSimCardStockDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteSimCardStockRequest) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *DeleteSimCardStockDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *DeleteSimCardStockDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteSimCardStockRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteSimCardStockDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteSimCardStockRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteSimCardStockRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *DeleteSimCardStockDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

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

func (h *DeleteSimCardStockDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteSimCardStockDescriptor() *DeleteSimCardStockDescriptor {
	return deleteSimCardStockDescriptor
}

type AllocateDescriptor struct{}

type AllocateDescriptorClientMsgHandle struct{}

type AllocateDescriptorServerMsgHandle struct{}

func (d *AllocateDescriptor) NewEmptyClientMsg() proto.Message {
	return &AllocateRequest{}
}

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

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

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

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

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

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

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

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

func (d *AllocateDescriptor) GetVerb() string {
	return "allocate"
}

func (d *AllocateDescriptor) GetMethodName() string {
	return "Allocate"
}

func (d *AllocateDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/Allocate"
}

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

func (d *AllocateDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *AllocateDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *AllocateDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *AllocateDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &AllocateDescriptorClientMsgHandle{}
}

func (d *AllocateDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &AllocateDescriptorServerMsgHandle{}
}

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

func (h *AllocateDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*AllocateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*AllocateRequest) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *AllocateDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *AllocateDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*AllocateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*AllocateRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *AllocateDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*AllocateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*AllocateRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *AllocateDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

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

func (h *AllocateDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetAllocateDescriptor() *AllocateDescriptor {
	return allocateDescriptor
}

type DeallocateDescriptor struct{}

type DeallocateDescriptorClientMsgHandle struct{}

type DeallocateDescriptorServerMsgHandle struct{}

func (d *DeallocateDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeallocateRequest{}
}

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

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

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

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

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

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

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

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

func (d *DeallocateDescriptor) GetVerb() string {
	return "deallocate"
}

func (d *DeallocateDescriptor) GetMethodName() string {
	return "Deallocate"
}

func (d *DeallocateDescriptor) GetFullMethodName() string {
	return "/ntt.cellular_api.v1.SimCardStockService/Deallocate"
}

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

func (d *DeallocateDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func (d *DeallocateDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return simCardStockServiceDescriptor
}

func (d *DeallocateDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return sim_card_stock.GetDescriptor()
}

func (d *DeallocateDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeallocateDescriptorClientMsgHandle{}
}

func (d *DeallocateDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeallocateDescriptorServerMsgHandle{}
}

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

func (h *DeallocateDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeallocateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeallocateRequest) []*sim_card_stock.Name
	})
	if ok {
		return sim_card_stock.SimCardStockNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *DeallocateDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *DeallocateDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeallocateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeallocateRequest) *sim_card_stock.SimCardStock
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeallocateDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeallocateRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeallocateRequest) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *DeallocateDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

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

func (h *DeallocateDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*sim_card_stock.SimCardStock
	})
	if ok {
		return sim_card_stock.SimCardStockList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeallocateDescriptor() *DeallocateDescriptor {
	return deallocateDescriptor
}

type SimCardStockServiceDescriptor struct{}

func (d *SimCardStockServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getSimCardStockDescriptor,
		batchGetSimCardStocksDescriptor,
		listSimCardStocksDescriptor,
		watchSimCardStockDescriptor,
		watchSimCardStocksDescriptor,
		createSimCardStockDescriptor,
		updateSimCardStockDescriptor,
		deleteSimCardStockDescriptor,
		allocateDescriptor,
		deallocateDescriptor,
	}
}

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

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

func (d *SimCardStockServiceDescriptor) GetApiName() string {
	return "SimCardStockService"
}

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

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

func GetSimCardStockServiceDescriptor() *SimCardStockServiceDescriptor {
	return simCardStockServiceDescriptor
}

func initDescriptors() {
	simCardStockServiceDescriptor = &SimCardStockServiceDescriptor{}
	getSimCardStockDescriptor = &GetSimCardStockDescriptor{}
	batchGetSimCardStocksDescriptor = &BatchGetSimCardStocksDescriptor{}
	listSimCardStocksDescriptor = &ListSimCardStocksDescriptor{}
	watchSimCardStockDescriptor = &WatchSimCardStockDescriptor{}
	watchSimCardStocksDescriptor = &WatchSimCardStocksDescriptor{}
	createSimCardStockDescriptor = &CreateSimCardStockDescriptor{}
	updateSimCardStockDescriptor = &UpdateSimCardStockDescriptor{}
	deleteSimCardStockDescriptor = &DeleteSimCardStockDescriptor{}
	allocateDescriptor = &AllocateDescriptor{}
	deallocateDescriptor = &DeallocateDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(simCardStockServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getSimCardStockDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetSimCardStocksDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listSimCardStocksDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchSimCardStockDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchSimCardStocksDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createSimCardStockDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateSimCardStockDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteSimCardStockDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(allocateDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deallocateDescriptor)
}

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