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

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

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

var (
	descriptorsInitialized              bool
	memberAssignmentServiceDescriptor   *MemberAssignmentServiceDescriptor
	getMemberAssignmentDescriptor       *GetMemberAssignmentDescriptor
	batchGetMemberAssignmentsDescriptor *BatchGetMemberAssignmentsDescriptor
	listMemberAssignmentsDescriptor     *ListMemberAssignmentsDescriptor
	watchMemberAssignmentDescriptor     *WatchMemberAssignmentDescriptor
	watchMemberAssignmentsDescriptor    *WatchMemberAssignmentsDescriptor
	updateMemberAssignmentDescriptor    *UpdateMemberAssignmentDescriptor
	deleteMemberAssignmentDescriptor    *DeleteMemberAssignmentDescriptor
	searchMemberAssignmentsDescriptor   *SearchMemberAssignmentsDescriptor
)

type GetMemberAssignmentDescriptor struct{}

type GetMemberAssignmentDescriptorClientMsgHandle struct{}

type GetMemberAssignmentDescriptorServerMsgHandle struct{}

func (d *GetMemberAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetMemberAssignmentRequest{}
}

func (d *GetMemberAssignmentDescriptor) NewEmptyServerMsg() proto.Message {
	return &member_assignment.MemberAssignment{}
}

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

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

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

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

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

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

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

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

func (d *GetMemberAssignmentDescriptor) GetMethodName() string {
	return "GetMemberAssignment"
}

func (d *GetMemberAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.MemberAssignmentService/GetMemberAssignment"
}

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

func (d *GetMemberAssignmentDescriptor) GetApiName() string {
	return "MemberAssignmentService"
}

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

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

func (d *GetMemberAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return memberAssignmentServiceDescriptor
}

func (d *GetMemberAssignmentDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return member_assignment.GetDescriptor()
}

func (d *GetMemberAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetMemberAssignmentDescriptorClientMsgHandle{}
}

func (d *GetMemberAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetMemberAssignmentDescriptorServerMsgHandle{}
}

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

func (h *GetMemberAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetMemberAssignmentRequest) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetMemberAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetMemberAssignmentRequest) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetMemberAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetMemberAssignmentRequest) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetMemberAssignmentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*member_assignment.MemberAssignment)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*member_assignment.MemberAssignment) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetMemberAssignmentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*member_assignment.MemberAssignment)
}

func (h *GetMemberAssignmentDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*member_assignment.MemberAssignment)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*member_assignment.MemberAssignment) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetMemberAssignmentDescriptor() *GetMemberAssignmentDescriptor {
	return getMemberAssignmentDescriptor
}

type BatchGetMemberAssignmentsDescriptor struct{}

type BatchGetMemberAssignmentsDescriptorClientMsgHandle struct{}

type BatchGetMemberAssignmentsDescriptorServerMsgHandle struct{}

func (d *BatchGetMemberAssignmentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetMemberAssignmentsRequest{}
}

func (d *BatchGetMemberAssignmentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetMemberAssignmentsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetMemberAssignmentsDescriptor) GetMethodName() string {
	return "BatchGetMemberAssignments"
}

func (d *BatchGetMemberAssignmentsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.MemberAssignmentService/BatchGetMemberAssignments"
}

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

func (d *BatchGetMemberAssignmentsDescriptor) GetApiName() string {
	return "MemberAssignmentService"
}

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

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

func (d *BatchGetMemberAssignmentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return memberAssignmentServiceDescriptor
}

func (d *BatchGetMemberAssignmentsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return member_assignment.GetDescriptor()
}

func (d *BatchGetMemberAssignmentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetMemberAssignmentsDescriptorClientMsgHandle{}
}

func (d *BatchGetMemberAssignmentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetMemberAssignmentsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetMemberAssignmentsRequest) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetMemberAssignmentsRequest) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetMemberAssignmentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetMemberAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetMemberAssignmentsResponse) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetMemberAssignmentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetMemberAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetMemberAssignmentsResponse) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetMemberAssignments(); len(resources) > 0 {
			return member_assignment.MemberAssignmentList(resources)
		}
	}
	return (member_assignment.MemberAssignmentList)(nil)
}

func GetBatchGetMemberAssignmentsDescriptor() *BatchGetMemberAssignmentsDescriptor {
	return batchGetMemberAssignmentsDescriptor
}

type ListMemberAssignmentsDescriptor struct{}

type ListMemberAssignmentsDescriptorClientMsgHandle struct{}

type ListMemberAssignmentsDescriptorServerMsgHandle struct{}

func (d *ListMemberAssignmentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListMemberAssignmentsRequest{}
}

func (d *ListMemberAssignmentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListMemberAssignmentsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListMemberAssignmentsDescriptor) GetMethodName() string {
	return "ListMemberAssignments"
}

func (d *ListMemberAssignmentsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.MemberAssignmentService/ListMemberAssignments"
}

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

func (d *ListMemberAssignmentsDescriptor) GetApiName() string {
	return "MemberAssignmentService"
}

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

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

func (d *ListMemberAssignmentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return memberAssignmentServiceDescriptor
}

func (d *ListMemberAssignmentsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return member_assignment.GetDescriptor()
}

func (d *ListMemberAssignmentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListMemberAssignmentsDescriptorClientMsgHandle{}
}

func (d *ListMemberAssignmentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListMemberAssignmentsDescriptorServerMsgHandle{}
}

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

func (h *ListMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListMemberAssignmentsRequest) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListMemberAssignmentsRequest) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListMemberAssignmentsRequest) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListMemberAssignmentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListMemberAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListMemberAssignmentsResponse) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListMemberAssignmentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListMemberAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListMemberAssignmentsResponse) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetMemberAssignments(); len(resources) > 0 {
			return member_assignment.MemberAssignmentList(resources)
		}
	}
	return (member_assignment.MemberAssignmentList)(nil)
}

func GetListMemberAssignmentsDescriptor() *ListMemberAssignmentsDescriptor {
	return listMemberAssignmentsDescriptor
}

type WatchMemberAssignmentDescriptor struct{}

type WatchMemberAssignmentDescriptorClientMsgHandle struct{}

type WatchMemberAssignmentDescriptorServerMsgHandle struct{}

func (d *WatchMemberAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchMemberAssignmentRequest{}
}

func (d *WatchMemberAssignmentDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchMemberAssignmentResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchMemberAssignmentDescriptor) GetMethodName() string {
	return "WatchMemberAssignment"
}

func (d *WatchMemberAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.MemberAssignmentService/WatchMemberAssignment"
}

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

func (d *WatchMemberAssignmentDescriptor) GetApiName() string {
	return "MemberAssignmentService"
}

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

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

func (d *WatchMemberAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return memberAssignmentServiceDescriptor
}

func (d *WatchMemberAssignmentDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return member_assignment.GetDescriptor()
}

func (d *WatchMemberAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchMemberAssignmentDescriptorClientMsgHandle{}
}

func (d *WatchMemberAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchMemberAssignmentDescriptorServerMsgHandle{}
}

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

func (h *WatchMemberAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchMemberAssignmentRequest) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchMemberAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchMemberAssignmentRequest) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchMemberAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchMemberAssignmentRequest) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchMemberAssignmentDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchMemberAssignmentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchMemberAssignmentResponse) *member_assignment.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *member_assignment.MemberAssignmentChange_Added_:
				return tResChange.Added.GetMemberAssignment().GetName()
			case *member_assignment.MemberAssignmentChange_Modified_:
				return tResChange.Modified.GetName()
			case *member_assignment.MemberAssignmentChange_Removed_:
				return tResChange.Removed.GetName()
			case *member_assignment.MemberAssignmentChange_Current_:
				return tResChange.Current.GetMemberAssignment().GetName()
			}
		}
	}
	return (*member_assignment.Name)(nil)
}

func (h *WatchMemberAssignmentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchMemberAssignmentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchMemberAssignmentResponse) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchMemberAssignmentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchMemberAssignmentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchMemberAssignmentResponse) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *member_assignment.MemberAssignmentChange_Added_:
				return tResChange.Added.GetMemberAssignment()
			case *member_assignment.MemberAssignmentChange_Modified_:
				return tResChange.Modified.GetMemberAssignment()
			case *member_assignment.MemberAssignmentChange_Current_:
				return tResChange.Current.GetMemberAssignment()
			}
		}
	}
	return (*member_assignment.MemberAssignment)(nil)
}

func (h *WatchMemberAssignmentDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchMemberAssignmentResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchMemberAssignmentResponse) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchMemberAssignmentDescriptor() *WatchMemberAssignmentDescriptor {
	return watchMemberAssignmentDescriptor
}

type WatchMemberAssignmentsDescriptor struct{}

type WatchMemberAssignmentsDescriptorClientMsgHandle struct{}

type WatchMemberAssignmentsDescriptorServerMsgHandle struct{}

func (d *WatchMemberAssignmentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchMemberAssignmentsRequest{}
}

func (d *WatchMemberAssignmentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchMemberAssignmentsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchMemberAssignmentsDescriptor) GetMethodName() string {
	return "WatchMemberAssignments"
}

func (d *WatchMemberAssignmentsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.MemberAssignmentService/WatchMemberAssignments"
}

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

func (d *WatchMemberAssignmentsDescriptor) GetApiName() string {
	return "MemberAssignmentService"
}

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

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

func (d *WatchMemberAssignmentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return memberAssignmentServiceDescriptor
}

func (d *WatchMemberAssignmentsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return member_assignment.GetDescriptor()
}

func (d *WatchMemberAssignmentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchMemberAssignmentsDescriptorClientMsgHandle{}
}

func (d *WatchMemberAssignmentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchMemberAssignmentsDescriptorServerMsgHandle{}
}

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

func (h *WatchMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchMemberAssignmentsRequest) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchMemberAssignmentsRequest) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchMemberAssignmentsRequest) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchMemberAssignmentsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchMemberAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchMemberAssignmentsResponse) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetMemberAssignmentChanges(); len(resChanges) > 0 {
			list := make(member_assignment.MemberAssignmentNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *member_assignment.MemberAssignmentChange_Added_:
					list = append(list, tResChange.Added.GetMemberAssignment().GetName())
				case *member_assignment.MemberAssignmentChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *member_assignment.MemberAssignmentChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *member_assignment.MemberAssignmentChange_Current_:
					list = append(list, tResChange.Current.GetMemberAssignment().GetName())
				}
			}
			return list
		}
	}
	return (member_assignment.MemberAssignmentNameList)(nil)
}

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

func (h *WatchMemberAssignmentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchMemberAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchMemberAssignmentsResponse) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchMemberAssignmentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchMemberAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchMemberAssignmentsResponse) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetMemberAssignmentChanges(); len(resChanges) > 0 {
			list := make(member_assignment.MemberAssignmentList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *member_assignment.MemberAssignmentChange_Added_:
					list = append(list, tResChange.Added.GetMemberAssignment())
				case *member_assignment.MemberAssignmentChange_Modified_:
					list = append(list, tResChange.Modified.GetMemberAssignment())
				case *member_assignment.MemberAssignmentChange_Current_:
					list = append(list, tResChange.Current.GetMemberAssignment())
				}
			}
			return list
		}
	}
	return (member_assignment.MemberAssignmentList)(nil)
}

func GetWatchMemberAssignmentsDescriptor() *WatchMemberAssignmentsDescriptor {
	return watchMemberAssignmentsDescriptor
}

type UpdateMemberAssignmentDescriptor struct{}

type UpdateMemberAssignmentDescriptorClientMsgHandle struct{}

type UpdateMemberAssignmentDescriptorServerMsgHandle struct{}

func (d *UpdateMemberAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateMemberAssignmentRequest{}
}

func (d *UpdateMemberAssignmentDescriptor) NewEmptyServerMsg() proto.Message {
	return &member_assignment.MemberAssignment{}
}

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

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

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

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

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

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

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

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

func (d *UpdateMemberAssignmentDescriptor) GetMethodName() string {
	return "UpdateMemberAssignment"
}

func (d *UpdateMemberAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.MemberAssignmentService/UpdateMemberAssignment"
}

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

func (d *UpdateMemberAssignmentDescriptor) GetApiName() string {
	return "MemberAssignmentService"
}

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

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

func (d *UpdateMemberAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return memberAssignmentServiceDescriptor
}

func (d *UpdateMemberAssignmentDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return member_assignment.GetDescriptor()
}

func (d *UpdateMemberAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateMemberAssignmentDescriptorClientMsgHandle{}
}

func (d *UpdateMemberAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateMemberAssignmentDescriptorServerMsgHandle{}
}

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

func (h *UpdateMemberAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateMemberAssignmentRequest) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateMemberAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateMemberAssignmentRequest) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetMemberAssignment()
	}
	return (*member_assignment.MemberAssignment)(nil)
}

func (h *UpdateMemberAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateMemberAssignmentRequest) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateMemberAssignmentDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*member_assignment.MemberAssignment)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*member_assignment.MemberAssignment) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateMemberAssignmentDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*member_assignment.MemberAssignment)
}

func (h *UpdateMemberAssignmentDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*member_assignment.MemberAssignment)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*member_assignment.MemberAssignment) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateMemberAssignmentDescriptor() *UpdateMemberAssignmentDescriptor {
	return updateMemberAssignmentDescriptor
}

type DeleteMemberAssignmentDescriptor struct{}

type DeleteMemberAssignmentDescriptorClientMsgHandle struct{}

type DeleteMemberAssignmentDescriptorServerMsgHandle struct{}

func (d *DeleteMemberAssignmentDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteMemberAssignmentRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteMemberAssignmentDescriptor) GetMethodName() string {
	return "DeleteMemberAssignment"
}

func (d *DeleteMemberAssignmentDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.MemberAssignmentService/DeleteMemberAssignment"
}

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

func (d *DeleteMemberAssignmentDescriptor) GetApiName() string {
	return "MemberAssignmentService"
}

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

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

func (d *DeleteMemberAssignmentDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return memberAssignmentServiceDescriptor
}

func (d *DeleteMemberAssignmentDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return member_assignment.GetDescriptor()
}

func (d *DeleteMemberAssignmentDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteMemberAssignmentDescriptorClientMsgHandle{}
}

func (d *DeleteMemberAssignmentDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteMemberAssignmentDescriptorServerMsgHandle{}
}

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

func (h *DeleteMemberAssignmentDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteMemberAssignmentRequest) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteMemberAssignmentDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteMemberAssignmentRequest) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteMemberAssignmentDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteMemberAssignmentRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteMemberAssignmentRequest) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteMemberAssignmentDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteMemberAssignmentDescriptor() *DeleteMemberAssignmentDescriptor {
	return deleteMemberAssignmentDescriptor
}

type SearchMemberAssignmentsDescriptor struct{}

type SearchMemberAssignmentsDescriptorClientMsgHandle struct{}

type SearchMemberAssignmentsDescriptorServerMsgHandle struct{}

func (d *SearchMemberAssignmentsDescriptor) NewEmptyClientMsg() proto.Message {
	return &SearchMemberAssignmentsRequest{}
}

func (d *SearchMemberAssignmentsDescriptor) NewEmptyServerMsg() proto.Message {
	return &SearchMemberAssignmentsResponse{}
}

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

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

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

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

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

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

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

func (d *SearchMemberAssignmentsDescriptor) GetVerb() string {
	return "search"
}

func (d *SearchMemberAssignmentsDescriptor) GetMethodName() string {
	return "SearchMemberAssignments"
}

func (d *SearchMemberAssignmentsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.MemberAssignmentService/SearchMemberAssignments"
}

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

func (d *SearchMemberAssignmentsDescriptor) GetApiName() string {
	return "MemberAssignmentService"
}

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

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

func (d *SearchMemberAssignmentsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return memberAssignmentServiceDescriptor
}

func (d *SearchMemberAssignmentsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return member_assignment.GetDescriptor()
}

func (d *SearchMemberAssignmentsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchMemberAssignmentsDescriptorClientMsgHandle{}
}

func (d *SearchMemberAssignmentsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchMemberAssignmentsDescriptorServerMsgHandle{}
}

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

func (h *SearchMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*SearchMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*SearchMemberAssignmentsRequest) []*member_assignment.Name
	})
	if ok {
		return member_assignment.MemberAssignmentNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *SearchMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SearchMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SearchMemberAssignmentsRequest) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SearchMemberAssignmentsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SearchMemberAssignmentsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SearchMemberAssignmentsRequest) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *SearchMemberAssignmentsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SearchMemberAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SearchMemberAssignmentsResponse) *member_assignment.MemberAssignment
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SearchMemberAssignmentsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SearchMemberAssignmentsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SearchMemberAssignmentsResponse) []*member_assignment.MemberAssignment
	})
	if ok {
		return member_assignment.MemberAssignmentList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetMemberAssignments(); len(resources) > 0 {
			return member_assignment.MemberAssignmentList(resources)
		}
	}
	return (member_assignment.MemberAssignmentList)(nil)
}

func GetSearchMemberAssignmentsDescriptor() *SearchMemberAssignmentsDescriptor {
	return searchMemberAssignmentsDescriptor
}

type MemberAssignmentServiceDescriptor struct{}

func (d *MemberAssignmentServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getMemberAssignmentDescriptor,
		batchGetMemberAssignmentsDescriptor,
		listMemberAssignmentsDescriptor,
		watchMemberAssignmentDescriptor,
		watchMemberAssignmentsDescriptor,
		updateMemberAssignmentDescriptor,
		deleteMemberAssignmentDescriptor,
		searchMemberAssignmentsDescriptor,
	}
}

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

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

func (d *MemberAssignmentServiceDescriptor) GetApiName() string {
	return "MemberAssignmentService"
}

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

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

func GetMemberAssignmentServiceDescriptor() *MemberAssignmentServiceDescriptor {
	return memberAssignmentServiceDescriptor
}

func initDescriptors() {
	memberAssignmentServiceDescriptor = &MemberAssignmentServiceDescriptor{}
	getMemberAssignmentDescriptor = &GetMemberAssignmentDescriptor{}
	batchGetMemberAssignmentsDescriptor = &BatchGetMemberAssignmentsDescriptor{}
	listMemberAssignmentsDescriptor = &ListMemberAssignmentsDescriptor{}
	watchMemberAssignmentDescriptor = &WatchMemberAssignmentDescriptor{}
	watchMemberAssignmentsDescriptor = &WatchMemberAssignmentsDescriptor{}
	updateMemberAssignmentDescriptor = &UpdateMemberAssignmentDescriptor{}
	deleteMemberAssignmentDescriptor = &DeleteMemberAssignmentDescriptor{}
	searchMemberAssignmentsDescriptor = &SearchMemberAssignmentsDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(memberAssignmentServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getMemberAssignmentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetMemberAssignmentsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listMemberAssignmentsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchMemberAssignmentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchMemberAssignmentsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateMemberAssignmentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteMemberAssignmentDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(searchMemberAssignmentsDescriptor)
}

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