service_projects_management_service.pb.descriptors.go

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

package service_projects_management_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 "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1/service_account"
	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.Project{}
	_ = &service_account.ServiceAccount{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized                       bool
	serviceProjectsManagementServiceDescriptor   *ServiceProjectsManagementServiceDescriptor
	listMyServiceProjectsDescriptor              *ListMyServiceProjectsDescriptor
	setupServiceProjectDescriptor                *SetupServiceProjectDescriptor
	reserveServiceNameDescriptor                 *ReserveServiceNameDescriptor
	deleteServiceReservationDescriptor           *DeleteServiceReservationDescriptor
	listServiceReservationsDescriptor            *ListServiceReservationsDescriptor
	listProjectServicesDescriptor                *ListProjectServicesDescriptor
	addRegionalAdminAccountForServicesDescriptor *AddRegionalAdminAccountForServicesDescriptor
)

type ListMyServiceProjectsDescriptor struct{}

type ListMyServiceProjectsDescriptorClientMsgHandle struct{}

type ListMyServiceProjectsDescriptorServerMsgHandle struct{}

func (d *ListMyServiceProjectsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListMyServiceProjectsRequest{}
}

func (d *ListMyServiceProjectsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListMyServiceProjectsResponse{}
}

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

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

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

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

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

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

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

func (d *ListMyServiceProjectsDescriptor) GetVerb() string {
	return "listMyServiceProjects"
}

func (d *ListMyServiceProjectsDescriptor) GetMethodName() string {
	return "ListMyServiceProjects"
}

func (d *ListMyServiceProjectsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.ServiceProjectsManagementService/ListMyServiceProjects"
}

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

func (d *ListMyServiceProjectsDescriptor) GetApiName() string {
	return "ServiceProjectsManagementService"
}

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

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

func (d *ListMyServiceProjectsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceProjectsManagementServiceDescriptor
}

func (d *ListMyServiceProjectsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project.GetDescriptor()
}

func (d *ListMyServiceProjectsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListMyServiceProjectsDescriptorClientMsgHandle{}
}

func (d *ListMyServiceProjectsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListMyServiceProjectsDescriptorServerMsgHandle{}
}

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

func (h *ListMyServiceProjectsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListMyServiceProjectsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListMyServiceProjectsRequest) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListMyServiceProjectsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListMyServiceProjectsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListMyServiceProjectsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListMyServiceProjectsRequest) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListMyServiceProjectsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListMyServiceProjectsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListMyServiceProjectsRequest) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *ListMyServiceProjectsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListMyServiceProjectsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListMyServiceProjectsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListMyServiceProjectsResponse) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListMyServiceProjectsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListMyServiceProjectsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListMyServiceProjectsResponse) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetProjects(); len(resources) > 0 {
			return project.ProjectList(resources)
		}
	}
	return (project.ProjectList)(nil)
}

func GetListMyServiceProjectsDescriptor() *ListMyServiceProjectsDescriptor {
	return listMyServiceProjectsDescriptor
}

type SetupServiceProjectDescriptor struct{}

type SetupServiceProjectDescriptorClientMsgHandle struct{}

type SetupServiceProjectDescriptorServerMsgHandle struct{}

func (d *SetupServiceProjectDescriptor) NewEmptyClientMsg() proto.Message {
	return &SetupServiceProjectRequest{}
}

func (d *SetupServiceProjectDescriptor) NewEmptyServerMsg() proto.Message {
	return &project.Project{}
}

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

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

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

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

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

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

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

func (d *SetupServiceProjectDescriptor) GetVerb() string {
	return "setupServiceProject"
}

func (d *SetupServiceProjectDescriptor) GetMethodName() string {
	return "SetupServiceProject"
}

func (d *SetupServiceProjectDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.ServiceProjectsManagementService/SetupServiceProject"
}

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

func (d *SetupServiceProjectDescriptor) GetApiName() string {
	return "ServiceProjectsManagementService"
}

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

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

func (d *SetupServiceProjectDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceProjectsManagementServiceDescriptor
}

func (d *SetupServiceProjectDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project.GetDescriptor()
}

func (d *SetupServiceProjectDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SetupServiceProjectDescriptorClientMsgHandle{}
}

func (d *SetupServiceProjectDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SetupServiceProjectDescriptorServerMsgHandle{}
}

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

func (h *SetupServiceProjectDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*SetupServiceProjectRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*SetupServiceProjectRequest) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *SetupServiceProjectDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *SetupServiceProjectDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SetupServiceProjectRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SetupServiceProjectRequest) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SetupServiceProjectDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SetupServiceProjectRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SetupServiceProjectRequest) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *SetupServiceProjectDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*project.Project)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*project.Project) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *SetupServiceProjectDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *SetupServiceProjectDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*project.Project)
}

func (h *SetupServiceProjectDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*project.Project)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*project.Project) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetSetupServiceProjectDescriptor() *SetupServiceProjectDescriptor {
	return setupServiceProjectDescriptor
}

type ReserveServiceNameDescriptor struct{}

type ReserveServiceNameDescriptorClientMsgHandle struct{}

type ReserveServiceNameDescriptorServerMsgHandle struct{}

func (d *ReserveServiceNameDescriptor) NewEmptyClientMsg() proto.Message {
	return &ReserveServiceNameRequest{}
}

func (d *ReserveServiceNameDescriptor) NewEmptyServerMsg() proto.Message {
	return &ReserveServiceNameResponse{}
}

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

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

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

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

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

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

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

func (d *ReserveServiceNameDescriptor) GetVerb() string {
	return "reserveServiceName"
}

func (d *ReserveServiceNameDescriptor) GetMethodName() string {
	return "ReserveServiceName"
}

func (d *ReserveServiceNameDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.ServiceProjectsManagementService/ReserveServiceName"
}

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

func (d *ReserveServiceNameDescriptor) GetApiName() string {
	return "ServiceProjectsManagementService"
}

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

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

func (d *ReserveServiceNameDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceProjectsManagementServiceDescriptor
}

func (d *ReserveServiceNameDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project.GetDescriptor()
}

func (d *ReserveServiceNameDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ReserveServiceNameDescriptorClientMsgHandle{}
}

func (d *ReserveServiceNameDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ReserveServiceNameDescriptorServerMsgHandle{}
}

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

func (h *ReserveServiceNameDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ReserveServiceNameRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ReserveServiceNameRequest) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ReserveServiceNameDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ReserveServiceNameDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ReserveServiceNameRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ReserveServiceNameRequest) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ReserveServiceNameDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ReserveServiceNameRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ReserveServiceNameRequest) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *ReserveServiceNameDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ReserveServiceNameResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ReserveServiceNameResponse) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ReserveServiceNameDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ReserveServiceNameDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ReserveServiceNameResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ReserveServiceNameResponse) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ReserveServiceNameDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ReserveServiceNameResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ReserveServiceNameResponse) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetReserveServiceNameDescriptor() *ReserveServiceNameDescriptor {
	return reserveServiceNameDescriptor
}

type DeleteServiceReservationDescriptor struct{}

type DeleteServiceReservationDescriptorClientMsgHandle struct{}

type DeleteServiceReservationDescriptorServerMsgHandle struct{}

func (d *DeleteServiceReservationDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteServiceReservationRequest{}
}

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

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

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

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

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

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

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

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

func (d *DeleteServiceReservationDescriptor) GetVerb() string {
	return "deleteServiceReservation"
}

func (d *DeleteServiceReservationDescriptor) GetMethodName() string {
	return "DeleteServiceReservation"
}

func (d *DeleteServiceReservationDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.ServiceProjectsManagementService/DeleteServiceReservation"
}

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

func (d *DeleteServiceReservationDescriptor) GetApiName() string {
	return "ServiceProjectsManagementService"
}

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

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

func (d *DeleteServiceReservationDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceProjectsManagementServiceDescriptor
}

func (d *DeleteServiceReservationDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project.GetDescriptor()
}

func (d *DeleteServiceReservationDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteServiceReservationDescriptorClientMsgHandle{}
}

func (d *DeleteServiceReservationDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteServiceReservationDescriptorServerMsgHandle{}
}

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

func (h *DeleteServiceReservationDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteServiceReservationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteServiceReservationRequest) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *DeleteServiceReservationDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *DeleteServiceReservationDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteServiceReservationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteServiceReservationRequest) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteServiceReservationDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteServiceReservationRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteServiceReservationRequest) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *DeleteServiceReservationDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

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

func (h *DeleteServiceReservationDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteServiceReservationDescriptor() *DeleteServiceReservationDescriptor {
	return deleteServiceReservationDescriptor
}

type ListServiceReservationsDescriptor struct{}

type ListServiceReservationsDescriptorClientMsgHandle struct{}

type ListServiceReservationsDescriptorServerMsgHandle struct{}

func (d *ListServiceReservationsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListServiceReservationsRequest{}
}

func (d *ListServiceReservationsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListServiceReservationsResponse{}
}

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

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

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

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

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

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

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

func (d *ListServiceReservationsDescriptor) GetVerb() string {
	return "listServiceReservations"
}

func (d *ListServiceReservationsDescriptor) GetMethodName() string {
	return "ListServiceReservations"
}

func (d *ListServiceReservationsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.ServiceProjectsManagementService/ListServiceReservations"
}

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

func (d *ListServiceReservationsDescriptor) GetApiName() string {
	return "ServiceProjectsManagementService"
}

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

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

func (d *ListServiceReservationsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceProjectsManagementServiceDescriptor
}

func (d *ListServiceReservationsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project.GetDescriptor()
}

func (d *ListServiceReservationsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListServiceReservationsDescriptorClientMsgHandle{}
}

func (d *ListServiceReservationsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListServiceReservationsDescriptorServerMsgHandle{}
}

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

func (h *ListServiceReservationsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListServiceReservationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListServiceReservationsRequest) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListServiceReservationsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListServiceReservationsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListServiceReservationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListServiceReservationsRequest) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListServiceReservationsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListServiceReservationsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListServiceReservationsRequest) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *ListServiceReservationsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListServiceReservationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListServiceReservationsResponse) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListServiceReservationsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListServiceReservationsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListServiceReservationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListServiceReservationsResponse) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListServiceReservationsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListServiceReservationsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListServiceReservationsResponse) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetListServiceReservationsDescriptor() *ListServiceReservationsDescriptor {
	return listServiceReservationsDescriptor
}

type ListProjectServicesDescriptor struct{}

type ListProjectServicesDescriptorClientMsgHandle struct{}

type ListProjectServicesDescriptorServerMsgHandle struct{}

func (d *ListProjectServicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListProjectServicesRequest{}
}

func (d *ListProjectServicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListProjectServicesResponse{}
}

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

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

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

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

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

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

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

func (d *ListProjectServicesDescriptor) GetVerb() string {
	return "listProjectServices"
}

func (d *ListProjectServicesDescriptor) GetMethodName() string {
	return "ListProjectServices"
}

func (d *ListProjectServicesDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.ServiceProjectsManagementService/ListProjectServices"
}

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

func (d *ListProjectServicesDescriptor) GetApiName() string {
	return "ServiceProjectsManagementService"
}

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

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

func (d *ListProjectServicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceProjectsManagementServiceDescriptor
}

func (d *ListProjectServicesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return project.GetDescriptor()
}

func (d *ListProjectServicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListProjectServicesDescriptorClientMsgHandle{}
}

func (d *ListProjectServicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListProjectServicesDescriptorServerMsgHandle{}
}

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

func (h *ListProjectServicesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListProjectServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListProjectServicesRequest) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListProjectServicesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListProjectServicesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListProjectServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListProjectServicesRequest) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListProjectServicesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListProjectServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListProjectServicesRequest) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *ListProjectServicesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListProjectServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListProjectServicesResponse) []*project.Name
	})
	if ok {
		return project.ProjectNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListProjectServicesDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListProjectServicesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListProjectServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListProjectServicesResponse) *project.Project
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListProjectServicesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListProjectServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListProjectServicesResponse) []*project.Project
	})
	if ok {
		return project.ProjectList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetListProjectServicesDescriptor() *ListProjectServicesDescriptor {
	return listProjectServicesDescriptor
}

type AddRegionalAdminAccountForServicesDescriptor struct{}

type AddRegionalAdminAccountForServicesDescriptorClientMsgHandle struct{}

type AddRegionalAdminAccountForServicesDescriptorServerMsgHandle struct{}

func (d *AddRegionalAdminAccountForServicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &AddRegionalAdminAccountForServicesRequest{}
}

func (d *AddRegionalAdminAccountForServicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &AddRegionalAdminAccountForServicesResponse{}
}

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

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

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

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

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

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

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

func (d *AddRegionalAdminAccountForServicesDescriptor) GetVerb() string {
	return "addRegionalAdminAccountForServices"
}

func (d *AddRegionalAdminAccountForServicesDescriptor) GetMethodName() string {
	return "AddRegionalAdminAccountForServices"
}

func (d *AddRegionalAdminAccountForServicesDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1.ServiceProjectsManagementService/AddRegionalAdminAccountForServices"
}

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

func (d *AddRegionalAdminAccountForServicesDescriptor) GetApiName() string {
	return "ServiceProjectsManagementService"
}

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

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

func (d *AddRegionalAdminAccountForServicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return serviceProjectsManagementServiceDescriptor
}

func (d *AddRegionalAdminAccountForServicesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return service_account.GetDescriptor()
}

func (d *AddRegionalAdminAccountForServicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &AddRegionalAdminAccountForServicesDescriptorClientMsgHandle{}
}

func (d *AddRegionalAdminAccountForServicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &AddRegionalAdminAccountForServicesDescriptorServerMsgHandle{}
}

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

func (h *AddRegionalAdminAccountForServicesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*AddRegionalAdminAccountForServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*AddRegionalAdminAccountForServicesRequest) []*service_account.Name
	})
	if ok {
		return service_account.ServiceAccountNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *AddRegionalAdminAccountForServicesDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*AddRegionalAdminAccountForServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*AddRegionalAdminAccountForServicesRequest) *service_account.ServiceAccount
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *AddRegionalAdminAccountForServicesDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*AddRegionalAdminAccountForServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*AddRegionalAdminAccountForServicesRequest) []*service_account.ServiceAccount
	})
	if ok {
		return service_account.ServiceAccountList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *AddRegionalAdminAccountForServicesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*AddRegionalAdminAccountForServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*AddRegionalAdminAccountForServicesResponse) []*service_account.Name
	})
	if ok {
		return service_account.ServiceAccountNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *AddRegionalAdminAccountForServicesDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*AddRegionalAdminAccountForServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*AddRegionalAdminAccountForServicesResponse) *service_account.ServiceAccount
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *AddRegionalAdminAccountForServicesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*AddRegionalAdminAccountForServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*AddRegionalAdminAccountForServicesResponse) []*service_account.ServiceAccount
	})
	if ok {
		return service_account.ServiceAccountList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetAddRegionalAdminAccountForServicesDescriptor() *AddRegionalAdminAccountForServicesDescriptor {
	return addRegionalAdminAccountForServicesDescriptor
}

type ServiceProjectsManagementServiceDescriptor struct{}

func (d *ServiceProjectsManagementServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		listMyServiceProjectsDescriptor,
		setupServiceProjectDescriptor,
		reserveServiceNameDescriptor,
		deleteServiceReservationDescriptor,
		listServiceReservationsDescriptor,
		listProjectServicesDescriptor,
		addRegionalAdminAccountForServicesDescriptor,
	}
}

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

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

func (d *ServiceProjectsManagementServiceDescriptor) GetApiName() string {
	return "ServiceProjectsManagementService"
}

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

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

func GetServiceProjectsManagementServiceDescriptor() *ServiceProjectsManagementServiceDescriptor {
	return serviceProjectsManagementServiceDescriptor
}

func initDescriptors() {
	serviceProjectsManagementServiceDescriptor = &ServiceProjectsManagementServiceDescriptor{}
	listMyServiceProjectsDescriptor = &ListMyServiceProjectsDescriptor{}
	setupServiceProjectDescriptor = &SetupServiceProjectDescriptor{}
	reserveServiceNameDescriptor = &ReserveServiceNameDescriptor{}
	deleteServiceReservationDescriptor = &DeleteServiceReservationDescriptor{}
	listServiceReservationsDescriptor = &ListServiceReservationsDescriptor{}
	listProjectServicesDescriptor = &ListProjectServicesDescriptor{}
	addRegionalAdminAccountForServicesDescriptor = &AddRegionalAdminAccountForServicesDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(serviceProjectsManagementServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listMyServiceProjectsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(setupServiceProjectDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(reserveServiceNameDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteServiceReservationDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listServiceReservationsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listProjectServicesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(addRegionalAdminAccountForServicesDescriptor)
}

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