group_service.pb.descriptors.go

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

package group_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 (
	group "github.com/cloudwan/edgelq-sdk/iam/resources/v1/group"
	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 (
	_ = &group.Group{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized   bool
	groupServiceDescriptor   *GroupServiceDescriptor
	getGroupDescriptor       *GetGroupDescriptor
	batchGetGroupsDescriptor *BatchGetGroupsDescriptor
	listGroupsDescriptor     *ListGroupsDescriptor
	watchGroupDescriptor     *WatchGroupDescriptor
	watchGroupsDescriptor    *WatchGroupsDescriptor
	createGroupDescriptor    *CreateGroupDescriptor
	updateGroupDescriptor    *UpdateGroupDescriptor
	deleteGroupDescriptor    *DeleteGroupDescriptor
)

type GetGroupDescriptor struct{}

type GetGroupDescriptorClientMsgHandle struct{}

type GetGroupDescriptorServerMsgHandle struct{}

func (d *GetGroupDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetGroupRequest{}
}

func (d *GetGroupDescriptor) NewEmptyServerMsg() proto.Message {
	return &group.Group{}
}

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

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

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

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

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

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

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

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

func (d *GetGroupDescriptor) GetMethodName() string {
	return "GetGroup"
}

func (d *GetGroupDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupService/GetGroup"
}

func (d *GetGroupDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1"
}

func (d *GetGroupDescriptor) GetApiName() string {
	return "GroupService"
}

func (d *GetGroupDescriptor) GetServiceDomain() string {
	return "iam.edgelq.com"
}

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

func (d *GetGroupDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupServiceDescriptor
}

func (d *GetGroupDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group.GetDescriptor()
}

func (d *GetGroupDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetGroupDescriptorClientMsgHandle{}
}

func (d *GetGroupDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetGroupDescriptorServerMsgHandle{}
}

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

func (h *GetGroupDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetGroupRequest) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetGroupDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetGroupRequest) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetGroupDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetGroupRequest) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetGroupDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*group.Group)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*group.Group) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetGroupDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*group.Group)
}

func (h *GetGroupDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*group.Group)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*group.Group) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetGroupDescriptor() *GetGroupDescriptor {
	return getGroupDescriptor
}

type BatchGetGroupsDescriptor struct{}

type BatchGetGroupsDescriptorClientMsgHandle struct{}

type BatchGetGroupsDescriptorServerMsgHandle struct{}

func (d *BatchGetGroupsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetGroupsRequest{}
}

func (d *BatchGetGroupsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetGroupsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetGroupsDescriptor) GetMethodName() string {
	return "BatchGetGroups"
}

func (d *BatchGetGroupsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupService/BatchGetGroups"
}

func (d *BatchGetGroupsDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1"
}

func (d *BatchGetGroupsDescriptor) GetApiName() string {
	return "GroupService"
}

func (d *BatchGetGroupsDescriptor) GetServiceDomain() string {
	return "iam.edgelq.com"
}

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

func (d *BatchGetGroupsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupServiceDescriptor
}

func (d *BatchGetGroupsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group.GetDescriptor()
}

func (d *BatchGetGroupsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetGroupsDescriptorClientMsgHandle{}
}

func (d *BatchGetGroupsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetGroupsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetGroupsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetGroupsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetGroupsRequest) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetGroupsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetGroupsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetGroupsRequest) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetGroupsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetGroupsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetGroupsResponse) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetGroupsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetGroupsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetGroupsResponse) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetGroups(); len(resources) > 0 {
			return group.GroupList(resources)
		}
	}
	return (group.GroupList)(nil)
}

func GetBatchGetGroupsDescriptor() *BatchGetGroupsDescriptor {
	return batchGetGroupsDescriptor
}

type ListGroupsDescriptor struct{}

type ListGroupsDescriptorClientMsgHandle struct{}

type ListGroupsDescriptorServerMsgHandle struct{}

func (d *ListGroupsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListGroupsRequest{}
}

func (d *ListGroupsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListGroupsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListGroupsDescriptor) GetMethodName() string {
	return "ListGroups"
}

func (d *ListGroupsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupService/ListGroups"
}

func (d *ListGroupsDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1"
}

func (d *ListGroupsDescriptor) GetApiName() string {
	return "GroupService"
}

func (d *ListGroupsDescriptor) GetServiceDomain() string {
	return "iam.edgelq.com"
}

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

func (d *ListGroupsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupServiceDescriptor
}

func (d *ListGroupsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group.GetDescriptor()
}

func (d *ListGroupsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListGroupsDescriptorClientMsgHandle{}
}

func (d *ListGroupsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListGroupsDescriptorServerMsgHandle{}
}

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

func (h *ListGroupsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListGroupsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListGroupsRequest) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListGroupsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListGroupsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListGroupsRequest) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListGroupsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListGroupsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListGroupsRequest) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListGroupsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListGroupsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListGroupsResponse) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListGroupsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListGroupsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListGroupsResponse) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetGroups(); len(resources) > 0 {
			return group.GroupList(resources)
		}
	}
	return (group.GroupList)(nil)
}

func GetListGroupsDescriptor() *ListGroupsDescriptor {
	return listGroupsDescriptor
}

type WatchGroupDescriptor struct{}

type WatchGroupDescriptorClientMsgHandle struct{}

type WatchGroupDescriptorServerMsgHandle struct{}

func (d *WatchGroupDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchGroupRequest{}
}

func (d *WatchGroupDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchGroupResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchGroupDescriptor) GetMethodName() string {
	return "WatchGroup"
}

func (d *WatchGroupDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupService/WatchGroup"
}

func (d *WatchGroupDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1"
}

func (d *WatchGroupDescriptor) GetApiName() string {
	return "GroupService"
}

func (d *WatchGroupDescriptor) GetServiceDomain() string {
	return "iam.edgelq.com"
}

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

func (d *WatchGroupDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupServiceDescriptor
}

func (d *WatchGroupDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group.GetDescriptor()
}

func (d *WatchGroupDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchGroupDescriptorClientMsgHandle{}
}

func (d *WatchGroupDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchGroupDescriptorServerMsgHandle{}
}

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

func (h *WatchGroupDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchGroupRequest) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchGroupDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchGroupRequest) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchGroupDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchGroupRequest) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchGroupDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchGroupResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchGroupResponse) *group.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *group.GroupChange_Added_:
				return tResChange.Added.GetGroup().GetName()
			case *group.GroupChange_Modified_:
				return tResChange.Modified.GetName()
			case *group.GroupChange_Removed_:
				return tResChange.Removed.GetName()
			case *group.GroupChange_Current_:
				return tResChange.Current.GetGroup().GetName()
			}
		}
	}
	return (*group.Name)(nil)
}

func (h *WatchGroupDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchGroupResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchGroupResponse) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchGroupDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchGroupResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchGroupResponse) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *group.GroupChange_Added_:
				return tResChange.Added.GetGroup()
			case *group.GroupChange_Modified_:
				return tResChange.Modified.GetGroup()
			case *group.GroupChange_Current_:
				return tResChange.Current.GetGroup()
			}
		}
	}
	return (*group.Group)(nil)
}

func (h *WatchGroupDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchGroupResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchGroupResponse) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchGroupDescriptor() *WatchGroupDescriptor {
	return watchGroupDescriptor
}

type WatchGroupsDescriptor struct{}

type WatchGroupsDescriptorClientMsgHandle struct{}

type WatchGroupsDescriptorServerMsgHandle struct{}

func (d *WatchGroupsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchGroupsRequest{}
}

func (d *WatchGroupsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchGroupsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchGroupsDescriptor) GetMethodName() string {
	return "WatchGroups"
}

func (d *WatchGroupsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupService/WatchGroups"
}

func (d *WatchGroupsDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1"
}

func (d *WatchGroupsDescriptor) GetApiName() string {
	return "GroupService"
}

func (d *WatchGroupsDescriptor) GetServiceDomain() string {
	return "iam.edgelq.com"
}

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

func (d *WatchGroupsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupServiceDescriptor
}

func (d *WatchGroupsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group.GetDescriptor()
}

func (d *WatchGroupsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchGroupsDescriptorClientMsgHandle{}
}

func (d *WatchGroupsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchGroupsDescriptorServerMsgHandle{}
}

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

func (h *WatchGroupsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchGroupsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchGroupsRequest) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchGroupsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchGroupsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchGroupsRequest) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchGroupsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchGroupsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchGroupsRequest) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchGroupsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchGroupsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchGroupsResponse) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetGroupChanges(); len(resChanges) > 0 {
			list := make(group.GroupNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *group.GroupChange_Added_:
					list = append(list, tResChange.Added.GetGroup().GetName())
				case *group.GroupChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *group.GroupChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *group.GroupChange_Current_:
					list = append(list, tResChange.Current.GetGroup().GetName())
				}
			}
			return list
		}
	}
	return (group.GroupNameList)(nil)
}

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

func (h *WatchGroupsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchGroupsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchGroupsResponse) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchGroupsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchGroupsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchGroupsResponse) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetGroupChanges(); len(resChanges) > 0 {
			list := make(group.GroupList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *group.GroupChange_Added_:
					list = append(list, tResChange.Added.GetGroup())
				case *group.GroupChange_Modified_:
					list = append(list, tResChange.Modified.GetGroup())
				case *group.GroupChange_Current_:
					list = append(list, tResChange.Current.GetGroup())
				}
			}
			return list
		}
	}
	return (group.GroupList)(nil)
}

func GetWatchGroupsDescriptor() *WatchGroupsDescriptor {
	return watchGroupsDescriptor
}

type CreateGroupDescriptor struct{}

type CreateGroupDescriptorClientMsgHandle struct{}

type CreateGroupDescriptorServerMsgHandle struct{}

func (d *CreateGroupDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateGroupRequest{}
}

func (d *CreateGroupDescriptor) NewEmptyServerMsg() proto.Message {
	return &group.Group{}
}

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

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

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

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

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

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

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

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

func (d *CreateGroupDescriptor) GetMethodName() string {
	return "CreateGroup"
}

func (d *CreateGroupDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupService/CreateGroup"
}

func (d *CreateGroupDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1"
}

func (d *CreateGroupDescriptor) GetApiName() string {
	return "GroupService"
}

func (d *CreateGroupDescriptor) GetServiceDomain() string {
	return "iam.edgelq.com"
}

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

func (d *CreateGroupDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupServiceDescriptor
}

func (d *CreateGroupDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group.GetDescriptor()
}

func (d *CreateGroupDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateGroupDescriptorClientMsgHandle{}
}

func (d *CreateGroupDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateGroupDescriptorServerMsgHandle{}
}

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

func (h *CreateGroupDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateGroupRequest) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateGroupDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateGroupRequest) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetGroup()
	}
	return (*group.Group)(nil)
}

func (h *CreateGroupDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateGroupRequest) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateGroupDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*group.Group)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*group.Group) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateGroupDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*group.Group)
}

func (h *CreateGroupDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*group.Group)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*group.Group) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateGroupDescriptor() *CreateGroupDescriptor {
	return createGroupDescriptor
}

type UpdateGroupDescriptor struct{}

type UpdateGroupDescriptorClientMsgHandle struct{}

type UpdateGroupDescriptorServerMsgHandle struct{}

func (d *UpdateGroupDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateGroupRequest{}
}

func (d *UpdateGroupDescriptor) NewEmptyServerMsg() proto.Message {
	return &group.Group{}
}

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

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

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

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

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

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

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

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

func (d *UpdateGroupDescriptor) GetMethodName() string {
	return "UpdateGroup"
}

func (d *UpdateGroupDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupService/UpdateGroup"
}

func (d *UpdateGroupDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1"
}

func (d *UpdateGroupDescriptor) GetApiName() string {
	return "GroupService"
}

func (d *UpdateGroupDescriptor) GetServiceDomain() string {
	return "iam.edgelq.com"
}

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

func (d *UpdateGroupDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupServiceDescriptor
}

func (d *UpdateGroupDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group.GetDescriptor()
}

func (d *UpdateGroupDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateGroupDescriptorClientMsgHandle{}
}

func (d *UpdateGroupDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateGroupDescriptorServerMsgHandle{}
}

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

func (h *UpdateGroupDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateGroupRequest) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateGroupDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateGroupRequest) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetGroup()
	}
	return (*group.Group)(nil)
}

func (h *UpdateGroupDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateGroupRequest) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateGroupDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*group.Group)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*group.Group) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateGroupDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*group.Group)
}

func (h *UpdateGroupDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*group.Group)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*group.Group) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateGroupDescriptor() *UpdateGroupDescriptor {
	return updateGroupDescriptor
}

type DeleteGroupDescriptor struct{}

type DeleteGroupDescriptorClientMsgHandle struct{}

type DeleteGroupDescriptorServerMsgHandle struct{}

func (d *DeleteGroupDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteGroupRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteGroupDescriptor) GetMethodName() string {
	return "DeleteGroup"
}

func (d *DeleteGroupDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupService/DeleteGroup"
}

func (d *DeleteGroupDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1"
}

func (d *DeleteGroupDescriptor) GetApiName() string {
	return "GroupService"
}

func (d *DeleteGroupDescriptor) GetServiceDomain() string {
	return "iam.edgelq.com"
}

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

func (d *DeleteGroupDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupServiceDescriptor
}

func (d *DeleteGroupDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group.GetDescriptor()
}

func (d *DeleteGroupDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteGroupDescriptorClientMsgHandle{}
}

func (d *DeleteGroupDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteGroupDescriptorServerMsgHandle{}
}

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

func (h *DeleteGroupDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteGroupRequest) []*group.Name
	})
	if ok {
		return group.GroupNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteGroupDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteGroupRequest) *group.Group
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteGroupDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteGroupRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteGroupRequest) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteGroupDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*group.Group
	})
	if ok {
		return group.GroupList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteGroupDescriptor() *DeleteGroupDescriptor {
	return deleteGroupDescriptor
}

type GroupServiceDescriptor struct{}

func (d *GroupServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getGroupDescriptor,
		batchGetGroupsDescriptor,
		listGroupsDescriptor,
		watchGroupDescriptor,
		watchGroupsDescriptor,
		createGroupDescriptor,
		updateGroupDescriptor,
		deleteGroupDescriptor,
	}
}

func (d *GroupServiceDescriptor) GetFullAPIName() string {
	return "/ntt.iam.v1.GroupService"
}

func (d *GroupServiceDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1"
}

func (d *GroupServiceDescriptor) GetApiName() string {
	return "GroupService"
}

func (d *GroupServiceDescriptor) GetServiceDomain() string {
	return "iam.edgelq.com"
}

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

func GetGroupServiceDescriptor() *GroupServiceDescriptor {
	return groupServiceDescriptor
}

func initDescriptors() {
	groupServiceDescriptor = &GroupServiceDescriptor{}
	getGroupDescriptor = &GetGroupDescriptor{}
	batchGetGroupsDescriptor = &BatchGetGroupsDescriptor{}
	listGroupsDescriptor = &ListGroupsDescriptor{}
	watchGroupDescriptor = &WatchGroupDescriptor{}
	watchGroupsDescriptor = &WatchGroupsDescriptor{}
	createGroupDescriptor = &CreateGroupDescriptor{}
	updateGroupDescriptor = &UpdateGroupDescriptor{}
	deleteGroupDescriptor = &DeleteGroupDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(groupServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getGroupDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetGroupsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listGroupsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchGroupDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchGroupsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createGroupDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateGroupDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteGroupDescriptor)
}

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