config_map_service.pb.descriptors.go

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

package config_map_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 (
	config_map "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha2/config_map"
	empty "github.com/golang/protobuf/ptypes/empty"
)

// 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 (
	_ = &config_map.ConfigMap{}
	_ = &empty.Empty{}
)

var (
	descriptorsInitialized       bool
	configMapServiceDescriptor   *ConfigMapServiceDescriptor
	getConfigMapDescriptor       *GetConfigMapDescriptor
	batchGetConfigMapsDescriptor *BatchGetConfigMapsDescriptor
	listConfigMapsDescriptor     *ListConfigMapsDescriptor
	watchConfigMapDescriptor     *WatchConfigMapDescriptor
	watchConfigMapsDescriptor    *WatchConfigMapsDescriptor
	createConfigMapDescriptor    *CreateConfigMapDescriptor
	updateConfigMapDescriptor    *UpdateConfigMapDescriptor
	deleteConfigMapDescriptor    *DeleteConfigMapDescriptor
)

type GetConfigMapDescriptor struct{}

type GetConfigMapDescriptorClientMsgHandle struct{}

type GetConfigMapDescriptorServerMsgHandle struct{}

func (d *GetConfigMapDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetConfigMapRequest{}
}

func (d *GetConfigMapDescriptor) NewEmptyServerMsg() proto.Message {
	return &config_map.ConfigMap{}
}

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

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

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

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

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

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

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

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

func (d *GetConfigMapDescriptor) GetMethodName() string {
	return "GetConfigMap"
}

func (d *GetConfigMapDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha2.ConfigMapService/GetConfigMap"
}

func (d *GetConfigMapDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha2"
}

func (d *GetConfigMapDescriptor) GetApiName() string {
	return "ConfigMapService"
}

func (d *GetConfigMapDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *GetConfigMapDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return configMapServiceDescriptor
}

func (d *GetConfigMapDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return config_map.GetDescriptor()
}

func (d *GetConfigMapDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetConfigMapDescriptorClientMsgHandle{}
}

func (d *GetConfigMapDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetConfigMapDescriptorServerMsgHandle{}
}

func (h *GetConfigMapDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*GetConfigMapRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*GetConfigMapRequest) *config_map.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if ref := typedMsg.GetName(); ref != nil {
			return &ref.Name
		}
	}
	return (*config_map.Name)(nil)
}

func (h *GetConfigMapDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetConfigMapRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetConfigMapRequest) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *GetConfigMapDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*config_map.ConfigMap)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*config_map.ConfigMap) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetGetConfigMapDescriptor() *GetConfigMapDescriptor {
	return getConfigMapDescriptor
}

type BatchGetConfigMapsDescriptor struct{}

type BatchGetConfigMapsDescriptorClientMsgHandle struct{}

type BatchGetConfigMapsDescriptorServerMsgHandle struct{}

func (d *BatchGetConfigMapsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetConfigMapsRequest{}
}

func (d *BatchGetConfigMapsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetConfigMapsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetConfigMapsDescriptor) GetMethodName() string {
	return "BatchGetConfigMaps"
}

func (d *BatchGetConfigMapsDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha2.ConfigMapService/BatchGetConfigMaps"
}

func (d *BatchGetConfigMapsDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha2"
}

func (d *BatchGetConfigMapsDescriptor) GetApiName() string {
	return "ConfigMapService"
}

func (d *BatchGetConfigMapsDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *BatchGetConfigMapsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return configMapServiceDescriptor
}

func (d *BatchGetConfigMapsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return config_map.GetDescriptor()
}

func (d *BatchGetConfigMapsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetConfigMapsDescriptorClientMsgHandle{}
}

func (d *BatchGetConfigMapsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetConfigMapsDescriptorServerMsgHandle{}
}

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

func (h *BatchGetConfigMapsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BatchGetConfigMapsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BatchGetConfigMapsRequest) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if refs := typedMsg.GetNames(); len(refs) > 0 {
			list := make(config_map.ConfigMapNameList, 0, len(refs))
			for _, ref := range refs {
				list = append(list, &ref.Name)
			}
			return list
		}
	}
	return (config_map.ConfigMapNameList)(nil)
}

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

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

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

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

func GetBatchGetConfigMapsDescriptor() *BatchGetConfigMapsDescriptor {
	return batchGetConfigMapsDescriptor
}

type ListConfigMapsDescriptor struct{}

type ListConfigMapsDescriptorClientMsgHandle struct{}

type ListConfigMapsDescriptorServerMsgHandle struct{}

func (d *ListConfigMapsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListConfigMapsRequest{}
}

func (d *ListConfigMapsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListConfigMapsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListConfigMapsDescriptor) GetMethodName() string {
	return "ListConfigMaps"
}

func (d *ListConfigMapsDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha2.ConfigMapService/ListConfigMaps"
}

func (d *ListConfigMapsDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha2"
}

func (d *ListConfigMapsDescriptor) GetApiName() string {
	return "ConfigMapService"
}

func (d *ListConfigMapsDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *ListConfigMapsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return configMapServiceDescriptor
}

func (d *ListConfigMapsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return config_map.GetDescriptor()
}

func (d *ListConfigMapsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListConfigMapsDescriptorClientMsgHandle{}
}

func (d *ListConfigMapsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListConfigMapsDescriptorServerMsgHandle{}
}

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

func (h *ListConfigMapsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListConfigMapsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListConfigMapsRequest) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

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

func GetListConfigMapsDescriptor() *ListConfigMapsDescriptor {
	return listConfigMapsDescriptor
}

type WatchConfigMapDescriptor struct{}

type WatchConfigMapDescriptorClientMsgHandle struct{}

type WatchConfigMapDescriptorServerMsgHandle struct{}

func (d *WatchConfigMapDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchConfigMapRequest{}
}

func (d *WatchConfigMapDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchConfigMapResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchConfigMapDescriptor) GetMethodName() string {
	return "WatchConfigMap"
}

func (d *WatchConfigMapDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha2.ConfigMapService/WatchConfigMap"
}

func (d *WatchConfigMapDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha2"
}

func (d *WatchConfigMapDescriptor) GetApiName() string {
	return "ConfigMapService"
}

func (d *WatchConfigMapDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *WatchConfigMapDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return configMapServiceDescriptor
}

func (d *WatchConfigMapDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return config_map.GetDescriptor()
}

func (d *WatchConfigMapDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchConfigMapDescriptorClientMsgHandle{}
}

func (d *WatchConfigMapDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchConfigMapDescriptorServerMsgHandle{}
}

func (h *WatchConfigMapDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchConfigMapRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchConfigMapRequest) *config_map.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if ref := typedMsg.GetName(); ref != nil {
			return &ref.Name
		}
	}
	return (*config_map.Name)(nil)
}

func (h *WatchConfigMapDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchConfigMapRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchConfigMapRequest) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchConfigMapDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchConfigMapResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchConfigMapResponse) *config_map.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *config_map.ConfigMapChange_Added_:
				return tResChange.Added.GetConfigMap().GetName()
			case *config_map.ConfigMapChange_Modified_:
				return tResChange.Modified.GetName()
			case *config_map.ConfigMapChange_Removed_:
				return tResChange.Removed.GetName()
			case *config_map.ConfigMapChange_Current_:
				return tResChange.Current.GetConfigMap().GetName()
			}
		}
	}
	return (*config_map.Name)(nil)
}

func (h *WatchConfigMapDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchConfigMapResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchConfigMapResponse) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetWatchConfigMapDescriptor() *WatchConfigMapDescriptor {
	return watchConfigMapDescriptor
}

type WatchConfigMapsDescriptor struct{}

type WatchConfigMapsDescriptorClientMsgHandle struct{}

type WatchConfigMapsDescriptorServerMsgHandle struct{}

func (d *WatchConfigMapsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchConfigMapsRequest{}
}

func (d *WatchConfigMapsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchConfigMapsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchConfigMapsDescriptor) GetMethodName() string {
	return "WatchConfigMaps"
}

func (d *WatchConfigMapsDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha2.ConfigMapService/WatchConfigMaps"
}

func (d *WatchConfigMapsDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha2"
}

func (d *WatchConfigMapsDescriptor) GetApiName() string {
	return "ConfigMapService"
}

func (d *WatchConfigMapsDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *WatchConfigMapsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return configMapServiceDescriptor
}

func (d *WatchConfigMapsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return config_map.GetDescriptor()
}

func (d *WatchConfigMapsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchConfigMapsDescriptorClientMsgHandle{}
}

func (d *WatchConfigMapsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchConfigMapsDescriptorServerMsgHandle{}
}

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

func (h *WatchConfigMapsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchConfigMapsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchConfigMapsRequest) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchConfigMapsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchConfigMapsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*WatchConfigMapsRequest) *config_map.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if ref := typedMsg.GetParent(); ref != nil {
			return &ref.ParentName
		}
	}
	return (*config_map.ParentName)(nil)
}

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

func (h *WatchConfigMapsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchConfigMapsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchConfigMapsResponse) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetConfigMapChanges(); len(resChanges) > 0 {
			list := make(config_map.ConfigMapNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *config_map.ConfigMapChange_Added_:
					list = append(list, tResChange.Added.GetConfigMap().GetName())
				case *config_map.ConfigMapChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *config_map.ConfigMapChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *config_map.ConfigMapChange_Current_:
					list = append(list, tResChange.Current.GetConfigMap().GetName())
				}
			}
			return list
		}
	}
	return (config_map.ConfigMapNameList)(nil)
}

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

func GetWatchConfigMapsDescriptor() *WatchConfigMapsDescriptor {
	return watchConfigMapsDescriptor
}

type CreateConfigMapDescriptor struct{}

type CreateConfigMapDescriptorClientMsgHandle struct{}

type CreateConfigMapDescriptorServerMsgHandle struct{}

func (d *CreateConfigMapDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateConfigMapRequest{}
}

func (d *CreateConfigMapDescriptor) NewEmptyServerMsg() proto.Message {
	return &config_map.ConfigMap{}
}

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

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

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

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

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

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

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

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

func (d *CreateConfigMapDescriptor) GetMethodName() string {
	return "CreateConfigMap"
}

func (d *CreateConfigMapDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha2.ConfigMapService/CreateConfigMap"
}

func (d *CreateConfigMapDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha2"
}

func (d *CreateConfigMapDescriptor) GetApiName() string {
	return "ConfigMapService"
}

func (d *CreateConfigMapDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *CreateConfigMapDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return configMapServiceDescriptor
}

func (d *CreateConfigMapDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return config_map.GetDescriptor()
}

func (d *CreateConfigMapDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateConfigMapDescriptorClientMsgHandle{}
}

func (d *CreateConfigMapDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateConfigMapDescriptorServerMsgHandle{}
}

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

func (h *CreateConfigMapDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateConfigMapRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateConfigMapRequest) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateConfigMapDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateConfigMapRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*CreateConfigMapRequest) *config_map.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if ref := typedMsg.GetParent(); ref != nil {
			return &ref.ParentName
		}
	}
	return (*config_map.ParentName)(nil)
}

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

func (h *CreateConfigMapDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*config_map.ConfigMap)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*config_map.ConfigMap) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetCreateConfigMapDescriptor() *CreateConfigMapDescriptor {
	return createConfigMapDescriptor
}

type UpdateConfigMapDescriptor struct{}

type UpdateConfigMapDescriptorClientMsgHandle struct{}

type UpdateConfigMapDescriptorServerMsgHandle struct{}

func (d *UpdateConfigMapDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateConfigMapRequest{}
}

func (d *UpdateConfigMapDescriptor) NewEmptyServerMsg() proto.Message {
	return &config_map.ConfigMap{}
}

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

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

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

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

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

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

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

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

func (d *UpdateConfigMapDescriptor) GetMethodName() string {
	return "UpdateConfigMap"
}

func (d *UpdateConfigMapDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha2.ConfigMapService/UpdateConfigMap"
}

func (d *UpdateConfigMapDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha2"
}

func (d *UpdateConfigMapDescriptor) GetApiName() string {
	return "ConfigMapService"
}

func (d *UpdateConfigMapDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *UpdateConfigMapDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return configMapServiceDescriptor
}

func (d *UpdateConfigMapDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return config_map.GetDescriptor()
}

func (d *UpdateConfigMapDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateConfigMapDescriptorClientMsgHandle{}
}

func (d *UpdateConfigMapDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateConfigMapDescriptorServerMsgHandle{}
}

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

func (h *UpdateConfigMapDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateConfigMapRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateConfigMapRequest) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *UpdateConfigMapDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*config_map.ConfigMap)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*config_map.ConfigMap) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetUpdateConfigMapDescriptor() *UpdateConfigMapDescriptor {
	return updateConfigMapDescriptor
}

type DeleteConfigMapDescriptor struct{}

type DeleteConfigMapDescriptorClientMsgHandle struct{}

type DeleteConfigMapDescriptorServerMsgHandle struct{}

func (d *DeleteConfigMapDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteConfigMapRequest{}
}

func (d *DeleteConfigMapDescriptor) NewEmptyServerMsg() proto.Message {
	return &empty.Empty{}
}

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

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

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

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

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

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

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

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

func (d *DeleteConfigMapDescriptor) GetMethodName() string {
	return "DeleteConfigMap"
}

func (d *DeleteConfigMapDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha2.ConfigMapService/DeleteConfigMap"
}

func (d *DeleteConfigMapDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha2"
}

func (d *DeleteConfigMapDescriptor) GetApiName() string {
	return "ConfigMapService"
}

func (d *DeleteConfigMapDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *DeleteConfigMapDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return configMapServiceDescriptor
}

func (d *DeleteConfigMapDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return config_map.GetDescriptor()
}

func (d *DeleteConfigMapDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteConfigMapDescriptorClientMsgHandle{}
}

func (d *DeleteConfigMapDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteConfigMapDescriptorServerMsgHandle{}
}

func (h *DeleteConfigMapDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*DeleteConfigMapRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*DeleteConfigMapRequest) *config_map.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if ref := typedMsg.GetName(); ref != nil {
			return &ref.Name
		}
	}
	return (*config_map.Name)(nil)
}

func (h *DeleteConfigMapDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteConfigMapRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteConfigMapRequest) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *DeleteConfigMapDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*empty.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*empty.Empty) []*config_map.Name
	})
	if ok {
		return config_map.ConfigMapNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetDeleteConfigMapDescriptor() *DeleteConfigMapDescriptor {
	return deleteConfigMapDescriptor
}

type ConfigMapServiceDescriptor struct{}

func (d *ConfigMapServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getConfigMapDescriptor,
		batchGetConfigMapsDescriptor,
		listConfigMapsDescriptor,
		watchConfigMapDescriptor,
		watchConfigMapsDescriptor,
		createConfigMapDescriptor,
		updateConfigMapDescriptor,
		deleteConfigMapDescriptor,
	}
}

func (d *ConfigMapServiceDescriptor) GetFullAPIName() string {
	return "/ntt.applications.v1alpha2.ConfigMapService"
}

func (d *ConfigMapServiceDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha2"
}

func (d *ConfigMapServiceDescriptor) GetApiName() string {
	return "ConfigMapService"
}

func (d *ConfigMapServiceDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func GetConfigMapServiceDescriptor() *ConfigMapServiceDescriptor {
	return configMapServiceDescriptor
}

func initDescriptors() {
	configMapServiceDescriptor = &ConfigMapServiceDescriptor{}
	getConfigMapDescriptor = &GetConfigMapDescriptor{}
	batchGetConfigMapsDescriptor = &BatchGetConfigMapsDescriptor{}
	listConfigMapsDescriptor = &ListConfigMapsDescriptor{}
	watchConfigMapDescriptor = &WatchConfigMapDescriptor{}
	watchConfigMapsDescriptor = &WatchConfigMapsDescriptor{}
	createConfigMapDescriptor = &CreateConfigMapDescriptor{}
	updateConfigMapDescriptor = &UpdateConfigMapDescriptor{}
	deleteConfigMapDescriptor = &DeleteConfigMapDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(configMapServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getConfigMapDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetConfigMapsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listConfigMapsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchConfigMapDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchConfigMapsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createConfigMapDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateConfigMapDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteConfigMapDescriptor)
}

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