github.com/cloudwan/edgelq-sdk@v1.15.4/iam/client/v1/group_member/group_member_service.pb.descriptors.go

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

package group_member_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_member "github.com/cloudwan/edgelq-sdk/iam/resources/v1/group_member"
	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_member.GroupMember{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized                bool
	groupMemberServiceDescriptor          *GroupMemberServiceDescriptor
	getGroupMemberDescriptor              *GetGroupMemberDescriptor
	batchGetGroupMembersDescriptor        *BatchGetGroupMembersDescriptor
	listGroupMembersDescriptor            *ListGroupMembersDescriptor
	watchGroupMemberDescriptor            *WatchGroupMemberDescriptor
	watchGroupMembersDescriptor           *WatchGroupMembersDescriptor
	createGroupMemberDescriptor           *CreateGroupMemberDescriptor
	updateGroupMemberDescriptor           *UpdateGroupMemberDescriptor
	deleteGroupMemberDescriptor           *DeleteGroupMemberDescriptor
	listGroupMembersWithMembersDescriptor *ListGroupMembersWithMembersDescriptor
)

type GetGroupMemberDescriptor struct{}

type GetGroupMemberDescriptorClientMsgHandle struct{}

type GetGroupMemberDescriptorServerMsgHandle struct{}

func (d *GetGroupMemberDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetGroupMemberRequest{}
}

func (d *GetGroupMemberDescriptor) NewEmptyServerMsg() proto.Message {
	return &group_member.GroupMember{}
}

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

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

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

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

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

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

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

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

func (d *GetGroupMemberDescriptor) GetMethodName() string {
	return "GetGroupMember"
}

func (d *GetGroupMemberDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupMemberService/GetGroupMember"
}

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

func (d *GetGroupMemberDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func (d *GetGroupMemberDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupMemberServiceDescriptor
}

func (d *GetGroupMemberDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group_member.GetDescriptor()
}

func (d *GetGroupMemberDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetGroupMemberDescriptorClientMsgHandle{}
}

func (d *GetGroupMemberDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetGroupMemberDescriptorServerMsgHandle{}
}

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

func (h *GetGroupMemberDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetGroupMemberRequest) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetGroupMemberDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetGroupMemberRequest) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetGroupMemberDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetGroupMemberRequest) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetGroupMemberDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*group_member.GroupMember)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*group_member.GroupMember) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetGroupMemberDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*group_member.GroupMember)
}

func (h *GetGroupMemberDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*group_member.GroupMember)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*group_member.GroupMember) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetGroupMemberDescriptor() *GetGroupMemberDescriptor {
	return getGroupMemberDescriptor
}

type BatchGetGroupMembersDescriptor struct{}

type BatchGetGroupMembersDescriptorClientMsgHandle struct{}

type BatchGetGroupMembersDescriptorServerMsgHandle struct{}

func (d *BatchGetGroupMembersDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetGroupMembersRequest{}
}

func (d *BatchGetGroupMembersDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetGroupMembersResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetGroupMembersDescriptor) GetMethodName() string {
	return "BatchGetGroupMembers"
}

func (d *BatchGetGroupMembersDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupMemberService/BatchGetGroupMembers"
}

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

func (d *BatchGetGroupMembersDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func (d *BatchGetGroupMembersDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupMemberServiceDescriptor
}

func (d *BatchGetGroupMembersDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group_member.GetDescriptor()
}

func (d *BatchGetGroupMembersDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetGroupMembersDescriptorClientMsgHandle{}
}

func (d *BatchGetGroupMembersDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetGroupMembersDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetGroupMembersDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetGroupMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetGroupMembersRequest) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetGroupMembersDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetGroupMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetGroupMembersRequest) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetGroupMembersDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetGroupMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetGroupMembersResponse) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetGroupMembersDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetGroupMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetGroupMembersResponse) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetGroupMembers(); len(resources) > 0 {
			return group_member.GroupMemberList(resources)
		}
	}
	return (group_member.GroupMemberList)(nil)
}

func GetBatchGetGroupMembersDescriptor() *BatchGetGroupMembersDescriptor {
	return batchGetGroupMembersDescriptor
}

type ListGroupMembersDescriptor struct{}

type ListGroupMembersDescriptorClientMsgHandle struct{}

type ListGroupMembersDescriptorServerMsgHandle struct{}

func (d *ListGroupMembersDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListGroupMembersRequest{}
}

func (d *ListGroupMembersDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListGroupMembersResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListGroupMembersDescriptor) GetMethodName() string {
	return "ListGroupMembers"
}

func (d *ListGroupMembersDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupMemberService/ListGroupMembers"
}

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

func (d *ListGroupMembersDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func (d *ListGroupMembersDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupMemberServiceDescriptor
}

func (d *ListGroupMembersDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group_member.GetDescriptor()
}

func (d *ListGroupMembersDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListGroupMembersDescriptorClientMsgHandle{}
}

func (d *ListGroupMembersDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListGroupMembersDescriptorServerMsgHandle{}
}

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

func (h *ListGroupMembersDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListGroupMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListGroupMembersRequest) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListGroupMembersDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListGroupMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListGroupMembersRequest) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListGroupMembersDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListGroupMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListGroupMembersRequest) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListGroupMembersDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListGroupMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListGroupMembersResponse) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListGroupMembersDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListGroupMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListGroupMembersResponse) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetGroupMembers(); len(resources) > 0 {
			return group_member.GroupMemberList(resources)
		}
	}
	return (group_member.GroupMemberList)(nil)
}

func GetListGroupMembersDescriptor() *ListGroupMembersDescriptor {
	return listGroupMembersDescriptor
}

type WatchGroupMemberDescriptor struct{}

type WatchGroupMemberDescriptorClientMsgHandle struct{}

type WatchGroupMemberDescriptorServerMsgHandle struct{}

func (d *WatchGroupMemberDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchGroupMemberRequest{}
}

func (d *WatchGroupMemberDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchGroupMemberResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchGroupMemberDescriptor) GetMethodName() string {
	return "WatchGroupMember"
}

func (d *WatchGroupMemberDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupMemberService/WatchGroupMember"
}

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

func (d *WatchGroupMemberDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func (d *WatchGroupMemberDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupMemberServiceDescriptor
}

func (d *WatchGroupMemberDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group_member.GetDescriptor()
}

func (d *WatchGroupMemberDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchGroupMemberDescriptorClientMsgHandle{}
}

func (d *WatchGroupMemberDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchGroupMemberDescriptorServerMsgHandle{}
}

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

func (h *WatchGroupMemberDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchGroupMemberRequest) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchGroupMemberDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchGroupMemberRequest) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchGroupMemberDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchGroupMemberRequest) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchGroupMemberDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchGroupMemberResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchGroupMemberResponse) *group_member.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *group_member.GroupMemberChange_Added_:
				return tResChange.Added.GetGroupMember().GetName()
			case *group_member.GroupMemberChange_Modified_:
				return tResChange.Modified.GetName()
			case *group_member.GroupMemberChange_Removed_:
				return tResChange.Removed.GetName()
			case *group_member.GroupMemberChange_Current_:
				return tResChange.Current.GetGroupMember().GetName()
			}
		}
	}
	return (*group_member.Name)(nil)
}

func (h *WatchGroupMemberDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchGroupMemberResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchGroupMemberResponse) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchGroupMemberDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchGroupMemberResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchGroupMemberResponse) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *group_member.GroupMemberChange_Added_:
				return tResChange.Added.GetGroupMember()
			case *group_member.GroupMemberChange_Modified_:
				return tResChange.Modified.GetGroupMember()
			case *group_member.GroupMemberChange_Current_:
				return tResChange.Current.GetGroupMember()
			}
		}
	}
	return (*group_member.GroupMember)(nil)
}

func (h *WatchGroupMemberDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchGroupMemberResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchGroupMemberResponse) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchGroupMemberDescriptor() *WatchGroupMemberDescriptor {
	return watchGroupMemberDescriptor
}

type WatchGroupMembersDescriptor struct{}

type WatchGroupMembersDescriptorClientMsgHandle struct{}

type WatchGroupMembersDescriptorServerMsgHandle struct{}

func (d *WatchGroupMembersDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchGroupMembersRequest{}
}

func (d *WatchGroupMembersDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchGroupMembersResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchGroupMembersDescriptor) GetMethodName() string {
	return "WatchGroupMembers"
}

func (d *WatchGroupMembersDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupMemberService/WatchGroupMembers"
}

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

func (d *WatchGroupMembersDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func (d *WatchGroupMembersDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupMemberServiceDescriptor
}

func (d *WatchGroupMembersDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group_member.GetDescriptor()
}

func (d *WatchGroupMembersDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchGroupMembersDescriptorClientMsgHandle{}
}

func (d *WatchGroupMembersDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchGroupMembersDescriptorServerMsgHandle{}
}

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

func (h *WatchGroupMembersDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchGroupMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchGroupMembersRequest) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchGroupMembersDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchGroupMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchGroupMembersRequest) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchGroupMembersDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchGroupMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchGroupMembersRequest) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchGroupMembersDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchGroupMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchGroupMembersResponse) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetGroupMemberChanges(); len(resChanges) > 0 {
			list := make(group_member.GroupMemberNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *group_member.GroupMemberChange_Added_:
					list = append(list, tResChange.Added.GetGroupMember().GetName())
				case *group_member.GroupMemberChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *group_member.GroupMemberChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *group_member.GroupMemberChange_Current_:
					list = append(list, tResChange.Current.GetGroupMember().GetName())
				}
			}
			return list
		}
	}
	return (group_member.GroupMemberNameList)(nil)
}

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

func (h *WatchGroupMembersDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchGroupMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchGroupMembersResponse) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchGroupMembersDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchGroupMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchGroupMembersResponse) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetGroupMemberChanges(); len(resChanges) > 0 {
			list := make(group_member.GroupMemberList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *group_member.GroupMemberChange_Added_:
					list = append(list, tResChange.Added.GetGroupMember())
				case *group_member.GroupMemberChange_Modified_:
					list = append(list, tResChange.Modified.GetGroupMember())
				case *group_member.GroupMemberChange_Current_:
					list = append(list, tResChange.Current.GetGroupMember())
				}
			}
			return list
		}
	}
	return (group_member.GroupMemberList)(nil)
}

func GetWatchGroupMembersDescriptor() *WatchGroupMembersDescriptor {
	return watchGroupMembersDescriptor
}

type CreateGroupMemberDescriptor struct{}

type CreateGroupMemberDescriptorClientMsgHandle struct{}

type CreateGroupMemberDescriptorServerMsgHandle struct{}

func (d *CreateGroupMemberDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateGroupMemberRequest{}
}

func (d *CreateGroupMemberDescriptor) NewEmptyServerMsg() proto.Message {
	return &group_member.GroupMember{}
}

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

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

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

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

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

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

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

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

func (d *CreateGroupMemberDescriptor) GetMethodName() string {
	return "CreateGroupMember"
}

func (d *CreateGroupMemberDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupMemberService/CreateGroupMember"
}

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

func (d *CreateGroupMemberDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func (d *CreateGroupMemberDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupMemberServiceDescriptor
}

func (d *CreateGroupMemberDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group_member.GetDescriptor()
}

func (d *CreateGroupMemberDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateGroupMemberDescriptorClientMsgHandle{}
}

func (d *CreateGroupMemberDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateGroupMemberDescriptorServerMsgHandle{}
}

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

func (h *CreateGroupMemberDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateGroupMemberRequest) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateGroupMemberDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateGroupMemberRequest) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetGroupMember()
	}
	return (*group_member.GroupMember)(nil)
}

func (h *CreateGroupMemberDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateGroupMemberRequest) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateGroupMemberDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*group_member.GroupMember)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*group_member.GroupMember) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateGroupMemberDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*group_member.GroupMember)
}

func (h *CreateGroupMemberDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*group_member.GroupMember)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*group_member.GroupMember) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateGroupMemberDescriptor() *CreateGroupMemberDescriptor {
	return createGroupMemberDescriptor
}

type UpdateGroupMemberDescriptor struct{}

type UpdateGroupMemberDescriptorClientMsgHandle struct{}

type UpdateGroupMemberDescriptorServerMsgHandle struct{}

func (d *UpdateGroupMemberDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateGroupMemberRequest{}
}

func (d *UpdateGroupMemberDescriptor) NewEmptyServerMsg() proto.Message {
	return &group_member.GroupMember{}
}

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

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

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

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

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

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

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

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

func (d *UpdateGroupMemberDescriptor) GetMethodName() string {
	return "UpdateGroupMember"
}

func (d *UpdateGroupMemberDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupMemberService/UpdateGroupMember"
}

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

func (d *UpdateGroupMemberDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func (d *UpdateGroupMemberDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupMemberServiceDescriptor
}

func (d *UpdateGroupMemberDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group_member.GetDescriptor()
}

func (d *UpdateGroupMemberDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateGroupMemberDescriptorClientMsgHandle{}
}

func (d *UpdateGroupMemberDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateGroupMemberDescriptorServerMsgHandle{}
}

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

func (h *UpdateGroupMemberDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateGroupMemberRequest) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateGroupMemberDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateGroupMemberRequest) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetGroupMember()
	}
	return (*group_member.GroupMember)(nil)
}

func (h *UpdateGroupMemberDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateGroupMemberRequest) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateGroupMemberDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*group_member.GroupMember)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*group_member.GroupMember) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateGroupMemberDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*group_member.GroupMember)
}

func (h *UpdateGroupMemberDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*group_member.GroupMember)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*group_member.GroupMember) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateGroupMemberDescriptor() *UpdateGroupMemberDescriptor {
	return updateGroupMemberDescriptor
}

type DeleteGroupMemberDescriptor struct{}

type DeleteGroupMemberDescriptorClientMsgHandle struct{}

type DeleteGroupMemberDescriptorServerMsgHandle struct{}

func (d *DeleteGroupMemberDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteGroupMemberRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteGroupMemberDescriptor) GetMethodName() string {
	return "DeleteGroupMember"
}

func (d *DeleteGroupMemberDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupMemberService/DeleteGroupMember"
}

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

func (d *DeleteGroupMemberDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func (d *DeleteGroupMemberDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupMemberServiceDescriptor
}

func (d *DeleteGroupMemberDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group_member.GetDescriptor()
}

func (d *DeleteGroupMemberDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteGroupMemberDescriptorClientMsgHandle{}
}

func (d *DeleteGroupMemberDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteGroupMemberDescriptorServerMsgHandle{}
}

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

func (h *DeleteGroupMemberDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteGroupMemberRequest) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteGroupMemberDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteGroupMemberRequest) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteGroupMemberDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteGroupMemberRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteGroupMemberRequest) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteGroupMemberDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteGroupMemberDescriptor() *DeleteGroupMemberDescriptor {
	return deleteGroupMemberDescriptor
}

type ListGroupMembersWithMembersDescriptor struct{}

type ListGroupMembersWithMembersDescriptorClientMsgHandle struct{}

type ListGroupMembersWithMembersDescriptorServerMsgHandle struct{}

func (d *ListGroupMembersWithMembersDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListGroupMembersWithMembersRequest{}
}

func (d *ListGroupMembersWithMembersDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListGroupMembersWithMembersResponse{}
}

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

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

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

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

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

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

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

func (d *ListGroupMembersWithMembersDescriptor) GetVerb() string {
	return "listGroupMembersWithMembers"
}

func (d *ListGroupMembersWithMembersDescriptor) GetMethodName() string {
	return "ListGroupMembersWithMembers"
}

func (d *ListGroupMembersWithMembersDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.GroupMemberService/ListGroupMembersWithMembers"
}

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

func (d *ListGroupMembersWithMembersDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func (d *ListGroupMembersWithMembersDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return groupMemberServiceDescriptor
}

func (d *ListGroupMembersWithMembersDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return group_member.GetDescriptor()
}

func (d *ListGroupMembersWithMembersDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListGroupMembersWithMembersDescriptorClientMsgHandle{}
}

func (d *ListGroupMembersWithMembersDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListGroupMembersWithMembersDescriptorServerMsgHandle{}
}

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

func (h *ListGroupMembersWithMembersDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListGroupMembersWithMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListGroupMembersWithMembersRequest) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListGroupMembersWithMembersDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListGroupMembersWithMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListGroupMembersWithMembersRequest) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListGroupMembersWithMembersDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListGroupMembersWithMembersRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListGroupMembersWithMembersRequest) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *ListGroupMembersWithMembersDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListGroupMembersWithMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListGroupMembersWithMembersResponse) []*group_member.Name
	})
	if ok {
		return group_member.GroupMemberNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListGroupMembersWithMembersDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListGroupMembersWithMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListGroupMembersWithMembersResponse) *group_member.GroupMember
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListGroupMembersWithMembersDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListGroupMembersWithMembersResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListGroupMembersWithMembersResponse) []*group_member.GroupMember
	})
	if ok {
		return group_member.GroupMemberList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetListGroupMembersWithMembersDescriptor() *ListGroupMembersWithMembersDescriptor {
	return listGroupMembersWithMembersDescriptor
}

type GroupMemberServiceDescriptor struct{}

func (d *GroupMemberServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getGroupMemberDescriptor,
		batchGetGroupMembersDescriptor,
		listGroupMembersDescriptor,
		watchGroupMemberDescriptor,
		watchGroupMembersDescriptor,
		createGroupMemberDescriptor,
		updateGroupMemberDescriptor,
		deleteGroupMemberDescriptor,
		listGroupMembersWithMembersDescriptor,
	}
}

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

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

func (d *GroupMemberServiceDescriptor) GetApiName() string {
	return "GroupMemberService"
}

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

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

func GetGroupMemberServiceDescriptor() *GroupMemberServiceDescriptor {
	return groupMemberServiceDescriptor
}

func initDescriptors() {
	groupMemberServiceDescriptor = &GroupMemberServiceDescriptor{}
	getGroupMemberDescriptor = &GetGroupMemberDescriptor{}
	batchGetGroupMembersDescriptor = &BatchGetGroupMembersDescriptor{}
	listGroupMembersDescriptor = &ListGroupMembersDescriptor{}
	watchGroupMemberDescriptor = &WatchGroupMemberDescriptor{}
	watchGroupMembersDescriptor = &WatchGroupMembersDescriptor{}
	createGroupMemberDescriptor = &CreateGroupMemberDescriptor{}
	updateGroupMemberDescriptor = &UpdateGroupMemberDescriptor{}
	deleteGroupMemberDescriptor = &DeleteGroupMemberDescriptor{}
	listGroupMembersWithMembersDescriptor = &ListGroupMembersWithMembersDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(groupMemberServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getGroupMemberDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetGroupMembersDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listGroupMembersDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchGroupMemberDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchGroupMembersDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createGroupMemberDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateGroupMemberDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteGroupMemberDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listGroupMembersWithMembersDescriptor)
}

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