github.com/cloudwan/edgelq-sdk@v1.15.4/meta/client/v1alpha2/region/region_service.pb.descriptors.go

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

package region_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 (
	region "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/region"
)

// 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 (
	_ = &region.Region{}
)

var (
	descriptorsInitialized    bool
	regionServiceDescriptor   *RegionServiceDescriptor
	getRegionDescriptor       *GetRegionDescriptor
	batchGetRegionsDescriptor *BatchGetRegionsDescriptor
	listRegionsDescriptor     *ListRegionsDescriptor
	watchRegionDescriptor     *WatchRegionDescriptor
	watchRegionsDescriptor    *WatchRegionsDescriptor
)

type GetRegionDescriptor struct{}

type GetRegionDescriptorClientMsgHandle struct{}

type GetRegionDescriptorServerMsgHandle struct{}

func (d *GetRegionDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetRegionRequest{}
}

func (d *GetRegionDescriptor) NewEmptyServerMsg() proto.Message {
	return &region.Region{}
}

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

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

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

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

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

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

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

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

func (d *GetRegionDescriptor) GetMethodName() string {
	return "GetRegion"
}

func (d *GetRegionDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.RegionService/GetRegion"
}

func (d *GetRegionDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *GetRegionDescriptor) GetApiName() string {
	return "RegionService"
}

func (d *GetRegionDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *GetRegionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return regionServiceDescriptor
}

func (d *GetRegionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return region.GetDescriptor()
}

func (d *GetRegionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetRegionDescriptorClientMsgHandle{}
}

func (d *GetRegionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetRegionDescriptorServerMsgHandle{}
}

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

func (h *GetRegionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetRegionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetRegionRequest) []*region.Name
	})
	if ok {
		return region.RegionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetRegionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetRegionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetRegionRequest) *region.Region
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetRegionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetRegionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetRegionRequest) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetRegionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*region.Region)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*region.Region) []*region.Name
	})
	if ok {
		return region.RegionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetRegionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*region.Region)
}

func (h *GetRegionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*region.Region)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*region.Region) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetRegionDescriptor() *GetRegionDescriptor {
	return getRegionDescriptor
}

type BatchGetRegionsDescriptor struct{}

type BatchGetRegionsDescriptorClientMsgHandle struct{}

type BatchGetRegionsDescriptorServerMsgHandle struct{}

func (d *BatchGetRegionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetRegionsRequest{}
}

func (d *BatchGetRegionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetRegionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetRegionsDescriptor) GetMethodName() string {
	return "BatchGetRegions"
}

func (d *BatchGetRegionsDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.RegionService/BatchGetRegions"
}

func (d *BatchGetRegionsDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *BatchGetRegionsDescriptor) GetApiName() string {
	return "RegionService"
}

func (d *BatchGetRegionsDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *BatchGetRegionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return regionServiceDescriptor
}

func (d *BatchGetRegionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return region.GetDescriptor()
}

func (d *BatchGetRegionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetRegionsDescriptorClientMsgHandle{}
}

func (d *BatchGetRegionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetRegionsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetRegionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetRegionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetRegionsRequest) *region.Region
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetRegionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetRegionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetRegionsRequest) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetRegionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetRegionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetRegionsResponse) *region.Region
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetRegionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetRegionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetRegionsResponse) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetRegions(); len(resources) > 0 {
			return region.RegionList(resources)
		}
	}
	return (region.RegionList)(nil)
}

func GetBatchGetRegionsDescriptor() *BatchGetRegionsDescriptor {
	return batchGetRegionsDescriptor
}

type ListRegionsDescriptor struct{}

type ListRegionsDescriptorClientMsgHandle struct{}

type ListRegionsDescriptorServerMsgHandle struct{}

func (d *ListRegionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListRegionsRequest{}
}

func (d *ListRegionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListRegionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListRegionsDescriptor) GetMethodName() string {
	return "ListRegions"
}

func (d *ListRegionsDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.RegionService/ListRegions"
}

func (d *ListRegionsDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *ListRegionsDescriptor) GetApiName() string {
	return "RegionService"
}

func (d *ListRegionsDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *ListRegionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return regionServiceDescriptor
}

func (d *ListRegionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return region.GetDescriptor()
}

func (d *ListRegionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListRegionsDescriptorClientMsgHandle{}
}

func (d *ListRegionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListRegionsDescriptorServerMsgHandle{}
}

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

func (h *ListRegionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListRegionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListRegionsRequest) []*region.Name
	})
	if ok {
		return region.RegionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListRegionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListRegionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListRegionsRequest) *region.Region
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListRegionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListRegionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListRegionsRequest) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListRegionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListRegionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListRegionsResponse) *region.Region
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListRegionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListRegionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListRegionsResponse) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetRegions(); len(resources) > 0 {
			return region.RegionList(resources)
		}
	}
	return (region.RegionList)(nil)
}

func GetListRegionsDescriptor() *ListRegionsDescriptor {
	return listRegionsDescriptor
}

type WatchRegionDescriptor struct{}

type WatchRegionDescriptorClientMsgHandle struct{}

type WatchRegionDescriptorServerMsgHandle struct{}

func (d *WatchRegionDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchRegionRequest{}
}

func (d *WatchRegionDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchRegionResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchRegionDescriptor) GetMethodName() string {
	return "WatchRegion"
}

func (d *WatchRegionDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.RegionService/WatchRegion"
}

func (d *WatchRegionDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *WatchRegionDescriptor) GetApiName() string {
	return "RegionService"
}

func (d *WatchRegionDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *WatchRegionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return regionServiceDescriptor
}

func (d *WatchRegionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return region.GetDescriptor()
}

func (d *WatchRegionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchRegionDescriptorClientMsgHandle{}
}

func (d *WatchRegionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchRegionDescriptorServerMsgHandle{}
}

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

func (h *WatchRegionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchRegionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchRegionRequest) []*region.Name
	})
	if ok {
		return region.RegionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchRegionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchRegionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchRegionRequest) *region.Region
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchRegionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchRegionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchRegionRequest) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchRegionDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchRegionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchRegionResponse) *region.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *region.RegionChange_Added_:
				return tResChange.Added.GetRegion().GetName()
			case *region.RegionChange_Modified_:
				return tResChange.Modified.GetName()
			case *region.RegionChange_Removed_:
				return tResChange.Removed.GetName()
			case *region.RegionChange_Current_:
				return tResChange.Current.GetRegion().GetName()
			}
		}
	}
	return (*region.Name)(nil)
}

func (h *WatchRegionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchRegionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchRegionResponse) []*region.Name
	})
	if ok {
		return region.RegionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchRegionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchRegionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchRegionResponse) *region.Region
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *region.RegionChange_Added_:
				return tResChange.Added.GetRegion()
			case *region.RegionChange_Modified_:
				return tResChange.Modified.GetRegion()
			case *region.RegionChange_Current_:
				return tResChange.Current.GetRegion()
			}
		}
	}
	return (*region.Region)(nil)
}

func (h *WatchRegionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchRegionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchRegionResponse) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchRegionDescriptor() *WatchRegionDescriptor {
	return watchRegionDescriptor
}

type WatchRegionsDescriptor struct{}

type WatchRegionsDescriptorClientMsgHandle struct{}

type WatchRegionsDescriptorServerMsgHandle struct{}

func (d *WatchRegionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchRegionsRequest{}
}

func (d *WatchRegionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchRegionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchRegionsDescriptor) GetMethodName() string {
	return "WatchRegions"
}

func (d *WatchRegionsDescriptor) GetFullMethodName() string {
	return "/ntt.meta.v1alpha2.RegionService/WatchRegions"
}

func (d *WatchRegionsDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *WatchRegionsDescriptor) GetApiName() string {
	return "RegionService"
}

func (d *WatchRegionsDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func (d *WatchRegionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return regionServiceDescriptor
}

func (d *WatchRegionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return region.GetDescriptor()
}

func (d *WatchRegionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchRegionsDescriptorClientMsgHandle{}
}

func (d *WatchRegionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchRegionsDescriptorServerMsgHandle{}
}

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

func (h *WatchRegionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchRegionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchRegionsRequest) []*region.Name
	})
	if ok {
		return region.RegionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchRegionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchRegionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchRegionsRequest) *region.Region
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchRegionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchRegionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchRegionsRequest) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchRegionsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchRegionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchRegionsResponse) []*region.Name
	})
	if ok {
		return region.RegionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetRegionChanges(); len(resChanges) > 0 {
			list := make(region.RegionNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *region.RegionChange_Added_:
					list = append(list, tResChange.Added.GetRegion().GetName())
				case *region.RegionChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *region.RegionChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *region.RegionChange_Current_:
					list = append(list, tResChange.Current.GetRegion().GetName())
				}
			}
			return list
		}
	}
	return (region.RegionNameList)(nil)
}

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

func (h *WatchRegionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchRegionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchRegionsResponse) *region.Region
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchRegionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchRegionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchRegionsResponse) []*region.Region
	})
	if ok {
		return region.RegionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetRegionChanges(); len(resChanges) > 0 {
			list := make(region.RegionList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *region.RegionChange_Added_:
					list = append(list, tResChange.Added.GetRegion())
				case *region.RegionChange_Modified_:
					list = append(list, tResChange.Modified.GetRegion())
				case *region.RegionChange_Current_:
					list = append(list, tResChange.Current.GetRegion())
				}
			}
			return list
		}
	}
	return (region.RegionList)(nil)
}

func GetWatchRegionsDescriptor() *WatchRegionsDescriptor {
	return watchRegionsDescriptor
}

type RegionServiceDescriptor struct{}

func (d *RegionServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getRegionDescriptor,
		batchGetRegionsDescriptor,
		listRegionsDescriptor,
		watchRegionDescriptor,
		watchRegionsDescriptor,
	}
}

func (d *RegionServiceDescriptor) GetFullAPIName() string {
	return "/ntt.meta.v1alpha2.RegionService"
}

func (d *RegionServiceDescriptor) GetProtoPkgName() string {
	return "ntt.meta.v1alpha2"
}

func (d *RegionServiceDescriptor) GetApiName() string {
	return "RegionService"
}

func (d *RegionServiceDescriptor) GetServiceDomain() string {
	return "meta.edgelq.com"
}

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

func GetRegionServiceDescriptor() *RegionServiceDescriptor {
	return regionServiceDescriptor
}

func initDescriptors() {
	regionServiceDescriptor = &RegionServiceDescriptor{}
	getRegionDescriptor = &GetRegionDescriptor{}
	batchGetRegionsDescriptor = &BatchGetRegionsDescriptor{}
	listRegionsDescriptor = &ListRegionsDescriptor{}
	watchRegionDescriptor = &WatchRegionDescriptor{}
	watchRegionsDescriptor = &WatchRegionsDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(regionServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getRegionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetRegionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listRegionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchRegionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchRegionsDescriptor)
}

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