project_invitation_service.pb.descriptors.go

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

package project_invitation_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 (
	project_invitation "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project_invitation"
	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 (
	_ = &project_invitation.ProjectInvitation{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized               bool
	projectInvitationServiceDescriptor   *ProjectInvitationServiceDescriptor
	getProjectInvitationDescriptor       *GetProjectInvitationDescriptor
	batchGetProjectInvitationsDescriptor *BatchGetProjectInvitationsDescriptor
	listProjectInvitationsDescriptor     *ListProjectInvitationsDescriptor
	watchProjectInvitationDescriptor     *WatchProjectInvitationDescriptor
	watchProjectInvitationsDescriptor    *WatchProjectInvitationsDescriptor
	createProjectInvitationDescriptor    *CreateProjectInvitationDescriptor
	updateProjectInvitationDescriptor    *UpdateProjectInvitationDescriptor
	deleteProjectInvitationDescriptor    *DeleteProjectInvitationDescriptor
	acceptProjectInvitationDescriptor    *AcceptProjectInvitationDescriptor
	declineProjectInvitationDescriptor   *DeclineProjectInvitationDescriptor
	listMyProjectInvitationsDescriptor   *ListMyProjectInvitationsDescriptor
	resendProjectInvitationDescriptor    *ResendProjectInvitationDescriptor
)

type GetProjectInvitationDescriptor struct{}

type GetProjectInvitationDescriptorClientMsgHandle struct{}

type GetProjectInvitationDescriptorServerMsgHandle struct{}

func (d *GetProjectInvitationDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetProjectInvitationRequest{}
}

func (d *GetProjectInvitationDescriptor) NewEmptyServerMsg() proto.Message {
	return &project_invitation.ProjectInvitation{}
}

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

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

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

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

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

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

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

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

func (d *GetProjectInvitationDescriptor) GetMethodName() string {
	return "GetProjectInvitation"
}

func (d *GetProjectInvitationDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/GetProjectInvitation"
}

func (d *GetProjectInvitationDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *GetProjectInvitationDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *GetProjectInvitationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *GetProjectInvitationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *GetProjectInvitationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetProjectInvitationDescriptorClientMsgHandle{}
}

func (d *GetProjectInvitationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetProjectInvitationDescriptorServerMsgHandle{}
}

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

func (h *GetProjectInvitationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetProjectInvitationRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetProjectInvitationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetProjectInvitationRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetProjectInvitationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetProjectInvitationRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetProjectInvitationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*project_invitation.ProjectInvitation)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*project_invitation.ProjectInvitation) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetProjectInvitationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*project_invitation.ProjectInvitation)
}

func (h *GetProjectInvitationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*project_invitation.ProjectInvitation)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*project_invitation.ProjectInvitation) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetProjectInvitationDescriptor() *GetProjectInvitationDescriptor {
	return getProjectInvitationDescriptor
}

type BatchGetProjectInvitationsDescriptor struct{}

type BatchGetProjectInvitationsDescriptorClientMsgHandle struct{}

type BatchGetProjectInvitationsDescriptorServerMsgHandle struct{}

func (d *BatchGetProjectInvitationsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetProjectInvitationsRequest{}
}

func (d *BatchGetProjectInvitationsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetProjectInvitationsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetProjectInvitationsDescriptor) GetMethodName() string {
	return "BatchGetProjectInvitations"
}

func (d *BatchGetProjectInvitationsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/BatchGetProjectInvitations"
}

func (d *BatchGetProjectInvitationsDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *BatchGetProjectInvitationsDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *BatchGetProjectInvitationsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *BatchGetProjectInvitationsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *BatchGetProjectInvitationsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetProjectInvitationsDescriptorClientMsgHandle{}
}

func (d *BatchGetProjectInvitationsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetProjectInvitationsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetProjectInvitationsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetProjectInvitationsRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetProjectInvitationsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetProjectInvitationsRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetProjectInvitationsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetProjectInvitationsResponse) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetProjectInvitationsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetProjectInvitationsResponse) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetProjectInvitations(); len(resources) > 0 {
			return project_invitation.ProjectInvitationList(resources)
		}
	}
	return (project_invitation.ProjectInvitationList)(nil)
}

func GetBatchGetProjectInvitationsDescriptor() *BatchGetProjectInvitationsDescriptor {
	return batchGetProjectInvitationsDescriptor
}

type ListProjectInvitationsDescriptor struct{}

type ListProjectInvitationsDescriptorClientMsgHandle struct{}

type ListProjectInvitationsDescriptorServerMsgHandle struct{}

func (d *ListProjectInvitationsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListProjectInvitationsRequest{}
}

func (d *ListProjectInvitationsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListProjectInvitationsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListProjectInvitationsDescriptor) GetMethodName() string {
	return "ListProjectInvitations"
}

func (d *ListProjectInvitationsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/ListProjectInvitations"
}

func (d *ListProjectInvitationsDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *ListProjectInvitationsDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *ListProjectInvitationsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *ListProjectInvitationsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *ListProjectInvitationsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListProjectInvitationsDescriptorClientMsgHandle{}
}

func (d *ListProjectInvitationsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListProjectInvitationsDescriptorServerMsgHandle{}
}

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

func (h *ListProjectInvitationsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListProjectInvitationsRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListProjectInvitationsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListProjectInvitationsRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListProjectInvitationsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListProjectInvitationsRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListProjectInvitationsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListProjectInvitationsResponse) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListProjectInvitationsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListProjectInvitationsResponse) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetProjectInvitations(); len(resources) > 0 {
			return project_invitation.ProjectInvitationList(resources)
		}
	}
	return (project_invitation.ProjectInvitationList)(nil)
}

func GetListProjectInvitationsDescriptor() *ListProjectInvitationsDescriptor {
	return listProjectInvitationsDescriptor
}

type WatchProjectInvitationDescriptor struct{}

type WatchProjectInvitationDescriptorClientMsgHandle struct{}

type WatchProjectInvitationDescriptorServerMsgHandle struct{}

func (d *WatchProjectInvitationDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchProjectInvitationRequest{}
}

func (d *WatchProjectInvitationDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchProjectInvitationResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchProjectInvitationDescriptor) GetMethodName() string {
	return "WatchProjectInvitation"
}

func (d *WatchProjectInvitationDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/WatchProjectInvitation"
}

func (d *WatchProjectInvitationDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *WatchProjectInvitationDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *WatchProjectInvitationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *WatchProjectInvitationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *WatchProjectInvitationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProjectInvitationDescriptorClientMsgHandle{}
}

func (d *WatchProjectInvitationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProjectInvitationDescriptorServerMsgHandle{}
}

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

func (h *WatchProjectInvitationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProjectInvitationRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchProjectInvitationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchProjectInvitationRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchProjectInvitationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchProjectInvitationRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchProjectInvitationDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchProjectInvitationResponse) *project_invitation.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *project_invitation.ProjectInvitationChange_Added_:
				return tResChange.Added.GetProjectInvitation().GetName()
			case *project_invitation.ProjectInvitationChange_Modified_:
				return tResChange.Modified.GetName()
			case *project_invitation.ProjectInvitationChange_Removed_:
				return tResChange.Removed.GetName()
			case *project_invitation.ProjectInvitationChange_Current_:
				return tResChange.Current.GetProjectInvitation().GetName()
			}
		}
	}
	return (*project_invitation.Name)(nil)
}

func (h *WatchProjectInvitationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProjectInvitationResponse) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchProjectInvitationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchProjectInvitationResponse) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *project_invitation.ProjectInvitationChange_Added_:
				return tResChange.Added.GetProjectInvitation()
			case *project_invitation.ProjectInvitationChange_Modified_:
				return tResChange.Modified.GetProjectInvitation()
			case *project_invitation.ProjectInvitationChange_Current_:
				return tResChange.Current.GetProjectInvitation()
			}
		}
	}
	return (*project_invitation.ProjectInvitation)(nil)
}

func (h *WatchProjectInvitationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchProjectInvitationResponse) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchProjectInvitationDescriptor() *WatchProjectInvitationDescriptor {
	return watchProjectInvitationDescriptor
}

type WatchProjectInvitationsDescriptor struct{}

type WatchProjectInvitationsDescriptorClientMsgHandle struct{}

type WatchProjectInvitationsDescriptorServerMsgHandle struct{}

func (d *WatchProjectInvitationsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchProjectInvitationsRequest{}
}

func (d *WatchProjectInvitationsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchProjectInvitationsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchProjectInvitationsDescriptor) GetMethodName() string {
	return "WatchProjectInvitations"
}

func (d *WatchProjectInvitationsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/WatchProjectInvitations"
}

func (d *WatchProjectInvitationsDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *WatchProjectInvitationsDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *WatchProjectInvitationsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *WatchProjectInvitationsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *WatchProjectInvitationsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProjectInvitationsDescriptorClientMsgHandle{}
}

func (d *WatchProjectInvitationsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchProjectInvitationsDescriptorServerMsgHandle{}
}

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

func (h *WatchProjectInvitationsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProjectInvitationsRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchProjectInvitationsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchProjectInvitationsRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchProjectInvitationsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchProjectInvitationsRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchProjectInvitationsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchProjectInvitationsResponse) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetProjectInvitationChanges(); len(resChanges) > 0 {
			list := make(project_invitation.ProjectInvitationNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *project_invitation.ProjectInvitationChange_Added_:
					list = append(list, tResChange.Added.GetProjectInvitation().GetName())
				case *project_invitation.ProjectInvitationChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *project_invitation.ProjectInvitationChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *project_invitation.ProjectInvitationChange_Current_:
					list = append(list, tResChange.Current.GetProjectInvitation().GetName())
				}
			}
			return list
		}
	}
	return (project_invitation.ProjectInvitationNameList)(nil)
}

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

func (h *WatchProjectInvitationsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchProjectInvitationsResponse) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchProjectInvitationsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchProjectInvitationsResponse) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetProjectInvitationChanges(); len(resChanges) > 0 {
			list := make(project_invitation.ProjectInvitationList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *project_invitation.ProjectInvitationChange_Added_:
					list = append(list, tResChange.Added.GetProjectInvitation())
				case *project_invitation.ProjectInvitationChange_Modified_:
					list = append(list, tResChange.Modified.GetProjectInvitation())
				case *project_invitation.ProjectInvitationChange_Current_:
					list = append(list, tResChange.Current.GetProjectInvitation())
				}
			}
			return list
		}
	}
	return (project_invitation.ProjectInvitationList)(nil)
}

func GetWatchProjectInvitationsDescriptor() *WatchProjectInvitationsDescriptor {
	return watchProjectInvitationsDescriptor
}

type CreateProjectInvitationDescriptor struct{}

type CreateProjectInvitationDescriptorClientMsgHandle struct{}

type CreateProjectInvitationDescriptorServerMsgHandle struct{}

func (d *CreateProjectInvitationDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateProjectInvitationRequest{}
}

func (d *CreateProjectInvitationDescriptor) NewEmptyServerMsg() proto.Message {
	return &project_invitation.ProjectInvitation{}
}

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

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

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

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

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

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

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

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

func (d *CreateProjectInvitationDescriptor) GetMethodName() string {
	return "CreateProjectInvitation"
}

func (d *CreateProjectInvitationDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/CreateProjectInvitation"
}

func (d *CreateProjectInvitationDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *CreateProjectInvitationDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *CreateProjectInvitationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *CreateProjectInvitationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *CreateProjectInvitationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateProjectInvitationDescriptorClientMsgHandle{}
}

func (d *CreateProjectInvitationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateProjectInvitationDescriptorServerMsgHandle{}
}

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

func (h *CreateProjectInvitationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateProjectInvitationRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateProjectInvitationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateProjectInvitationRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetProjectInvitation()
	}
	return (*project_invitation.ProjectInvitation)(nil)
}

func (h *CreateProjectInvitationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateProjectInvitationRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateProjectInvitationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*project_invitation.ProjectInvitation)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*project_invitation.ProjectInvitation) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateProjectInvitationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*project_invitation.ProjectInvitation)
}

func (h *CreateProjectInvitationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*project_invitation.ProjectInvitation)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*project_invitation.ProjectInvitation) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateProjectInvitationDescriptor() *CreateProjectInvitationDescriptor {
	return createProjectInvitationDescriptor
}

type UpdateProjectInvitationDescriptor struct{}

type UpdateProjectInvitationDescriptorClientMsgHandle struct{}

type UpdateProjectInvitationDescriptorServerMsgHandle struct{}

func (d *UpdateProjectInvitationDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateProjectInvitationRequest{}
}

func (d *UpdateProjectInvitationDescriptor) NewEmptyServerMsg() proto.Message {
	return &project_invitation.ProjectInvitation{}
}

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

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

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

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

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

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

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

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

func (d *UpdateProjectInvitationDescriptor) GetMethodName() string {
	return "UpdateProjectInvitation"
}

func (d *UpdateProjectInvitationDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/UpdateProjectInvitation"
}

func (d *UpdateProjectInvitationDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *UpdateProjectInvitationDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *UpdateProjectInvitationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *UpdateProjectInvitationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *UpdateProjectInvitationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateProjectInvitationDescriptorClientMsgHandle{}
}

func (d *UpdateProjectInvitationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateProjectInvitationDescriptorServerMsgHandle{}
}

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

func (h *UpdateProjectInvitationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateProjectInvitationRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateProjectInvitationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateProjectInvitationRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetProjectInvitation()
	}
	return (*project_invitation.ProjectInvitation)(nil)
}

func (h *UpdateProjectInvitationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateProjectInvitationRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateProjectInvitationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*project_invitation.ProjectInvitation)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*project_invitation.ProjectInvitation) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateProjectInvitationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*project_invitation.ProjectInvitation)
}

func (h *UpdateProjectInvitationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*project_invitation.ProjectInvitation)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*project_invitation.ProjectInvitation) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateProjectInvitationDescriptor() *UpdateProjectInvitationDescriptor {
	return updateProjectInvitationDescriptor
}

type DeleteProjectInvitationDescriptor struct{}

type DeleteProjectInvitationDescriptorClientMsgHandle struct{}

type DeleteProjectInvitationDescriptorServerMsgHandle struct{}

func (d *DeleteProjectInvitationDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteProjectInvitationRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteProjectInvitationDescriptor) GetMethodName() string {
	return "DeleteProjectInvitation"
}

func (d *DeleteProjectInvitationDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/DeleteProjectInvitation"
}

func (d *DeleteProjectInvitationDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *DeleteProjectInvitationDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *DeleteProjectInvitationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *DeleteProjectInvitationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *DeleteProjectInvitationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteProjectInvitationDescriptorClientMsgHandle{}
}

func (d *DeleteProjectInvitationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteProjectInvitationDescriptorServerMsgHandle{}
}

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

func (h *DeleteProjectInvitationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteProjectInvitationRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteProjectInvitationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteProjectInvitationRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteProjectInvitationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteProjectInvitationRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteProjectInvitationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteProjectInvitationDescriptor() *DeleteProjectInvitationDescriptor {
	return deleteProjectInvitationDescriptor
}

type AcceptProjectInvitationDescriptor struct{}

type AcceptProjectInvitationDescriptorClientMsgHandle struct{}

type AcceptProjectInvitationDescriptorServerMsgHandle struct{}

func (d *AcceptProjectInvitationDescriptor) NewEmptyClientMsg() proto.Message {
	return &AcceptProjectInvitationRequest{}
}

func (d *AcceptProjectInvitationDescriptor) NewEmptyServerMsg() proto.Message {
	return &AcceptProjectInvitationResponse{}
}

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

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

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

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

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

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

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

func (d *AcceptProjectInvitationDescriptor) GetVerb() string {
	return "accept"
}

func (d *AcceptProjectInvitationDescriptor) GetMethodName() string {
	return "AcceptProjectInvitation"
}

func (d *AcceptProjectInvitationDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/AcceptProjectInvitation"
}

func (d *AcceptProjectInvitationDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *AcceptProjectInvitationDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *AcceptProjectInvitationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *AcceptProjectInvitationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *AcceptProjectInvitationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &AcceptProjectInvitationDescriptorClientMsgHandle{}
}

func (d *AcceptProjectInvitationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &AcceptProjectInvitationDescriptorServerMsgHandle{}
}

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

func (h *AcceptProjectInvitationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*AcceptProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*AcceptProjectInvitationRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *AcceptProjectInvitationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*AcceptProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*AcceptProjectInvitationRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *AcceptProjectInvitationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*AcceptProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*AcceptProjectInvitationRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *AcceptProjectInvitationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*AcceptProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*AcceptProjectInvitationResponse) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *AcceptProjectInvitationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*AcceptProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*AcceptProjectInvitationResponse) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *AcceptProjectInvitationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*AcceptProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*AcceptProjectInvitationResponse) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetAcceptProjectInvitationDescriptor() *AcceptProjectInvitationDescriptor {
	return acceptProjectInvitationDescriptor
}

type DeclineProjectInvitationDescriptor struct{}

type DeclineProjectInvitationDescriptorClientMsgHandle struct{}

type DeclineProjectInvitationDescriptorServerMsgHandle struct{}

func (d *DeclineProjectInvitationDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeclineProjectInvitationRequest{}
}

func (d *DeclineProjectInvitationDescriptor) NewEmptyServerMsg() proto.Message {
	return &DeclineProjectInvitationResponse{}
}

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

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

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

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

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

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

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

func (d *DeclineProjectInvitationDescriptor) GetVerb() string {
	return "decline"
}

func (d *DeclineProjectInvitationDescriptor) GetMethodName() string {
	return "DeclineProjectInvitation"
}

func (d *DeclineProjectInvitationDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/DeclineProjectInvitation"
}

func (d *DeclineProjectInvitationDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *DeclineProjectInvitationDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *DeclineProjectInvitationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *DeclineProjectInvitationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *DeclineProjectInvitationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeclineProjectInvitationDescriptorClientMsgHandle{}
}

func (d *DeclineProjectInvitationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeclineProjectInvitationDescriptorServerMsgHandle{}
}

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

func (h *DeclineProjectInvitationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeclineProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeclineProjectInvitationRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeclineProjectInvitationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeclineProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeclineProjectInvitationRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeclineProjectInvitationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeclineProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeclineProjectInvitationRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *DeclineProjectInvitationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeclineProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeclineProjectInvitationResponse) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeclineProjectInvitationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeclineProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeclineProjectInvitationResponse) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeclineProjectInvitationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeclineProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeclineProjectInvitationResponse) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeclineProjectInvitationDescriptor() *DeclineProjectInvitationDescriptor {
	return declineProjectInvitationDescriptor
}

type ListMyProjectInvitationsDescriptor struct{}

type ListMyProjectInvitationsDescriptorClientMsgHandle struct{}

type ListMyProjectInvitationsDescriptorServerMsgHandle struct{}

func (d *ListMyProjectInvitationsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListMyProjectInvitationsRequest{}
}

func (d *ListMyProjectInvitationsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListMyProjectInvitationsResponse{}
}

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

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

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

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

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

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

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

func (d *ListMyProjectInvitationsDescriptor) GetVerb() string {
	return "listMy"
}

func (d *ListMyProjectInvitationsDescriptor) GetMethodName() string {
	return "ListMyProjectInvitations"
}

func (d *ListMyProjectInvitationsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/ListMyProjectInvitations"
}

func (d *ListMyProjectInvitationsDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *ListMyProjectInvitationsDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *ListMyProjectInvitationsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *ListMyProjectInvitationsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *ListMyProjectInvitationsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListMyProjectInvitationsDescriptorClientMsgHandle{}
}

func (d *ListMyProjectInvitationsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListMyProjectInvitationsDescriptorServerMsgHandle{}
}

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

func (h *ListMyProjectInvitationsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListMyProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListMyProjectInvitationsRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListMyProjectInvitationsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListMyProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListMyProjectInvitationsRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListMyProjectInvitationsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListMyProjectInvitationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListMyProjectInvitationsRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *ListMyProjectInvitationsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListMyProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListMyProjectInvitationsResponse) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListMyProjectInvitationsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListMyProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListMyProjectInvitationsResponse) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListMyProjectInvitationsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListMyProjectInvitationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListMyProjectInvitationsResponse) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetListMyProjectInvitationsDescriptor() *ListMyProjectInvitationsDescriptor {
	return listMyProjectInvitationsDescriptor
}

type ResendProjectInvitationDescriptor struct{}

type ResendProjectInvitationDescriptorClientMsgHandle struct{}

type ResendProjectInvitationDescriptorServerMsgHandle struct{}

func (d *ResendProjectInvitationDescriptor) NewEmptyClientMsg() proto.Message {
	return &ResendProjectInvitationRequest{}
}

func (d *ResendProjectInvitationDescriptor) NewEmptyServerMsg() proto.Message {
	return &ResendProjectInvitationResponse{}
}

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

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

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

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

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

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

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

func (d *ResendProjectInvitationDescriptor) GetVerb() string {
	return "resend"
}

func (d *ResendProjectInvitationDescriptor) GetMethodName() string {
	return "ResendProjectInvitation"
}

func (d *ResendProjectInvitationDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService/ResendProjectInvitation"
}

func (d *ResendProjectInvitationDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *ResendProjectInvitationDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func (d *ResendProjectInvitationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return projectInvitationServiceDescriptor
}

func (d *ResendProjectInvitationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project_invitation.GetDescriptor()
}

func (d *ResendProjectInvitationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ResendProjectInvitationDescriptorClientMsgHandle{}
}

func (d *ResendProjectInvitationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ResendProjectInvitationDescriptorServerMsgHandle{}
}

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

func (h *ResendProjectInvitationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ResendProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ResendProjectInvitationRequest) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ResendProjectInvitationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ResendProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ResendProjectInvitationRequest) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ResendProjectInvitationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ResendProjectInvitationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ResendProjectInvitationRequest) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *ResendProjectInvitationDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ResendProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ResendProjectInvitationResponse) []*project_invitation.Name
	})
	if ok {
		return project_invitation.ProjectInvitationNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ResendProjectInvitationDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ResendProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ResendProjectInvitationResponse) *project_invitation.ProjectInvitation
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ResendProjectInvitationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ResendProjectInvitationResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ResendProjectInvitationResponse) []*project_invitation.ProjectInvitation
	})
	if ok {
		return project_invitation.ProjectInvitationList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetResendProjectInvitationDescriptor() *ResendProjectInvitationDescriptor {
	return resendProjectInvitationDescriptor
}

type ProjectInvitationServiceDescriptor struct{}

func (d *ProjectInvitationServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getProjectInvitationDescriptor,
		batchGetProjectInvitationsDescriptor,
		listProjectInvitationsDescriptor,
		watchProjectInvitationDescriptor,
		watchProjectInvitationsDescriptor,
		createProjectInvitationDescriptor,
		updateProjectInvitationDescriptor,
		deleteProjectInvitationDescriptor,
		acceptProjectInvitationDescriptor,
		declineProjectInvitationDescriptor,
		listMyProjectInvitationsDescriptor,
		resendProjectInvitationDescriptor,
	}
}

func (d *ProjectInvitationServiceDescriptor) GetFullAPIName() string {
	return "/ntt.iam.v1alpha2.ProjectInvitationService"
}

func (d *ProjectInvitationServiceDescriptor) GetProtoPkgName() string {
	return "ntt.iam.v1alpha2"
}

func (d *ProjectInvitationServiceDescriptor) GetApiName() string {
	return "ProjectInvitationService"
}

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

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

func GetProjectInvitationServiceDescriptor() *ProjectInvitationServiceDescriptor {
	return projectInvitationServiceDescriptor
}

func initDescriptors() {
	projectInvitationServiceDescriptor = &ProjectInvitationServiceDescriptor{}
	getProjectInvitationDescriptor = &GetProjectInvitationDescriptor{}
	batchGetProjectInvitationsDescriptor = &BatchGetProjectInvitationsDescriptor{}
	listProjectInvitationsDescriptor = &ListProjectInvitationsDescriptor{}
	watchProjectInvitationDescriptor = &WatchProjectInvitationDescriptor{}
	watchProjectInvitationsDescriptor = &WatchProjectInvitationsDescriptor{}
	createProjectInvitationDescriptor = &CreateProjectInvitationDescriptor{}
	updateProjectInvitationDescriptor = &UpdateProjectInvitationDescriptor{}
	deleteProjectInvitationDescriptor = &DeleteProjectInvitationDescriptor{}
	acceptProjectInvitationDescriptor = &AcceptProjectInvitationDescriptor{}
	declineProjectInvitationDescriptor = &DeclineProjectInvitationDescriptor{}
	listMyProjectInvitationsDescriptor = &ListMyProjectInvitationsDescriptor{}
	resendProjectInvitationDescriptor = &ResendProjectInvitationDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(projectInvitationServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getProjectInvitationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetProjectInvitationsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listProjectInvitationsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchProjectInvitationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchProjectInvitationsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createProjectInvitationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateProjectInvitationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteProjectInvitationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(acceptProjectInvitationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(declineProjectInvitationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listMyProjectInvitationsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(resendProjectInvitationDescriptor)
}

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