github.com/cloudwan/edgelq-sdk@v1.15.4/iam/client/v1alpha2/permission/permission_service.pb.descriptors.go

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

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

var (
	descriptorsInitialized        bool
	permissionServiceDescriptor   *PermissionServiceDescriptor
	getPermissionDescriptor       *GetPermissionDescriptor
	batchGetPermissionsDescriptor *BatchGetPermissionsDescriptor
	listPermissionsDescriptor     *ListPermissionsDescriptor
	watchPermissionDescriptor     *WatchPermissionDescriptor
	watchPermissionsDescriptor    *WatchPermissionsDescriptor
	createPermissionDescriptor    *CreatePermissionDescriptor
	updatePermissionDescriptor    *UpdatePermissionDescriptor
	deletePermissionDescriptor    *DeletePermissionDescriptor
)

type GetPermissionDescriptor struct{}

type GetPermissionDescriptorClientMsgHandle struct{}

type GetPermissionDescriptorServerMsgHandle struct{}

func (d *GetPermissionDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetPermissionRequest{}
}

func (d *GetPermissionDescriptor) NewEmptyServerMsg() proto.Message {
	return &permission.Permission{}
}

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

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

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

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

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

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

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

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

func (d *GetPermissionDescriptor) GetMethodName() string {
	return "GetPermission"
}

func (d *GetPermissionDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.PermissionService/GetPermission"
}

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

func (d *GetPermissionDescriptor) GetApiName() string {
	return "PermissionService"
}

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

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

func (d *GetPermissionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return permissionServiceDescriptor
}

func (d *GetPermissionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return permission.GetDescriptor()
}

func (d *GetPermissionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetPermissionDescriptorClientMsgHandle{}
}

func (d *GetPermissionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetPermissionDescriptorServerMsgHandle{}
}

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

func (h *GetPermissionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetPermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetPermissionRequest) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetPermissionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetPermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetPermissionRequest) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetPermissionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetPermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetPermissionRequest) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetPermissionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*permission.Permission)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*permission.Permission) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetPermissionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*permission.Permission)
}

func (h *GetPermissionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*permission.Permission)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*permission.Permission) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetPermissionDescriptor() *GetPermissionDescriptor {
	return getPermissionDescriptor
}

type BatchGetPermissionsDescriptor struct{}

type BatchGetPermissionsDescriptorClientMsgHandle struct{}

type BatchGetPermissionsDescriptorServerMsgHandle struct{}

func (d *BatchGetPermissionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetPermissionsRequest{}
}

func (d *BatchGetPermissionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetPermissionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetPermissionsDescriptor) GetMethodName() string {
	return "BatchGetPermissions"
}

func (d *BatchGetPermissionsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.PermissionService/BatchGetPermissions"
}

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

func (d *BatchGetPermissionsDescriptor) GetApiName() string {
	return "PermissionService"
}

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

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

func (d *BatchGetPermissionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return permissionServiceDescriptor
}

func (d *BatchGetPermissionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return permission.GetDescriptor()
}

func (d *BatchGetPermissionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetPermissionsDescriptorClientMsgHandle{}
}

func (d *BatchGetPermissionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetPermissionsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetPermissionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetPermissionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetPermissionsRequest) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetPermissionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetPermissionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetPermissionsRequest) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetPermissionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetPermissionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetPermissionsResponse) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetPermissionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetPermissionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetPermissionsResponse) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetPermissions(); len(resources) > 0 {
			return permission.PermissionList(resources)
		}
	}
	return (permission.PermissionList)(nil)
}

func GetBatchGetPermissionsDescriptor() *BatchGetPermissionsDescriptor {
	return batchGetPermissionsDescriptor
}

type ListPermissionsDescriptor struct{}

type ListPermissionsDescriptorClientMsgHandle struct{}

type ListPermissionsDescriptorServerMsgHandle struct{}

func (d *ListPermissionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListPermissionsRequest{}
}

func (d *ListPermissionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListPermissionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListPermissionsDescriptor) GetMethodName() string {
	return "ListPermissions"
}

func (d *ListPermissionsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.PermissionService/ListPermissions"
}

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

func (d *ListPermissionsDescriptor) GetApiName() string {
	return "PermissionService"
}

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

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

func (d *ListPermissionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return permissionServiceDescriptor
}

func (d *ListPermissionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return permission.GetDescriptor()
}

func (d *ListPermissionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListPermissionsDescriptorClientMsgHandle{}
}

func (d *ListPermissionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListPermissionsDescriptorServerMsgHandle{}
}

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

func (h *ListPermissionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListPermissionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListPermissionsRequest) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListPermissionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListPermissionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListPermissionsRequest) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListPermissionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListPermissionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListPermissionsRequest) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListPermissionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListPermissionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListPermissionsResponse) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListPermissionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListPermissionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListPermissionsResponse) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetPermissions(); len(resources) > 0 {
			return permission.PermissionList(resources)
		}
	}
	return (permission.PermissionList)(nil)
}

func GetListPermissionsDescriptor() *ListPermissionsDescriptor {
	return listPermissionsDescriptor
}

type WatchPermissionDescriptor struct{}

type WatchPermissionDescriptorClientMsgHandle struct{}

type WatchPermissionDescriptorServerMsgHandle struct{}

func (d *WatchPermissionDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchPermissionRequest{}
}

func (d *WatchPermissionDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchPermissionResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchPermissionDescriptor) GetMethodName() string {
	return "WatchPermission"
}

func (d *WatchPermissionDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.PermissionService/WatchPermission"
}

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

func (d *WatchPermissionDescriptor) GetApiName() string {
	return "PermissionService"
}

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

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

func (d *WatchPermissionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return permissionServiceDescriptor
}

func (d *WatchPermissionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return permission.GetDescriptor()
}

func (d *WatchPermissionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPermissionDescriptorClientMsgHandle{}
}

func (d *WatchPermissionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPermissionDescriptorServerMsgHandle{}
}

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

func (h *WatchPermissionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPermissionRequest) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPermissionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPermissionRequest) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchPermissionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPermissionRequest) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchPermissionDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchPermissionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchPermissionResponse) *permission.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *permission.PermissionChange_Added_:
				return tResChange.Added.GetPermission().GetName()
			case *permission.PermissionChange_Modified_:
				return tResChange.Modified.GetName()
			case *permission.PermissionChange_Removed_:
				return tResChange.Removed.GetName()
			case *permission.PermissionChange_Current_:
				return tResChange.Current.GetPermission().GetName()
			}
		}
	}
	return (*permission.Name)(nil)
}

func (h *WatchPermissionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPermissionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPermissionResponse) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPermissionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPermissionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPermissionResponse) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *permission.PermissionChange_Added_:
				return tResChange.Added.GetPermission()
			case *permission.PermissionChange_Modified_:
				return tResChange.Modified.GetPermission()
			case *permission.PermissionChange_Current_:
				return tResChange.Current.GetPermission()
			}
		}
	}
	return (*permission.Permission)(nil)
}

func (h *WatchPermissionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPermissionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPermissionResponse) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchPermissionDescriptor() *WatchPermissionDescriptor {
	return watchPermissionDescriptor
}

type WatchPermissionsDescriptor struct{}

type WatchPermissionsDescriptorClientMsgHandle struct{}

type WatchPermissionsDescriptorServerMsgHandle struct{}

func (d *WatchPermissionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchPermissionsRequest{}
}

func (d *WatchPermissionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchPermissionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchPermissionsDescriptor) GetMethodName() string {
	return "WatchPermissions"
}

func (d *WatchPermissionsDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.PermissionService/WatchPermissions"
}

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

func (d *WatchPermissionsDescriptor) GetApiName() string {
	return "PermissionService"
}

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

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

func (d *WatchPermissionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return permissionServiceDescriptor
}

func (d *WatchPermissionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return permission.GetDescriptor()
}

func (d *WatchPermissionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPermissionsDescriptorClientMsgHandle{}
}

func (d *WatchPermissionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPermissionsDescriptorServerMsgHandle{}
}

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

func (h *WatchPermissionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPermissionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPermissionsRequest) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPermissionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPermissionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPermissionsRequest) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchPermissionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPermissionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPermissionsRequest) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchPermissionsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPermissionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPermissionsResponse) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetPermissionChanges(); len(resChanges) > 0 {
			list := make(permission.PermissionNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *permission.PermissionChange_Added_:
					list = append(list, tResChange.Added.GetPermission().GetName())
				case *permission.PermissionChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *permission.PermissionChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *permission.PermissionChange_Current_:
					list = append(list, tResChange.Current.GetPermission().GetName())
				}
			}
			return list
		}
	}
	return (permission.PermissionNameList)(nil)
}

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

func (h *WatchPermissionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchPermissionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchPermissionsResponse) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchPermissionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchPermissionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchPermissionsResponse) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetPermissionChanges(); len(resChanges) > 0 {
			list := make(permission.PermissionList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *permission.PermissionChange_Added_:
					list = append(list, tResChange.Added.GetPermission())
				case *permission.PermissionChange_Modified_:
					list = append(list, tResChange.Modified.GetPermission())
				case *permission.PermissionChange_Current_:
					list = append(list, tResChange.Current.GetPermission())
				}
			}
			return list
		}
	}
	return (permission.PermissionList)(nil)
}

func GetWatchPermissionsDescriptor() *WatchPermissionsDescriptor {
	return watchPermissionsDescriptor
}

type CreatePermissionDescriptor struct{}

type CreatePermissionDescriptorClientMsgHandle struct{}

type CreatePermissionDescriptorServerMsgHandle struct{}

func (d *CreatePermissionDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreatePermissionRequest{}
}

func (d *CreatePermissionDescriptor) NewEmptyServerMsg() proto.Message {
	return &permission.Permission{}
}

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

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

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

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

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

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

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

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

func (d *CreatePermissionDescriptor) GetMethodName() string {
	return "CreatePermission"
}

func (d *CreatePermissionDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.PermissionService/CreatePermission"
}

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

func (d *CreatePermissionDescriptor) GetApiName() string {
	return "PermissionService"
}

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

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

func (d *CreatePermissionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return permissionServiceDescriptor
}

func (d *CreatePermissionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return permission.GetDescriptor()
}

func (d *CreatePermissionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreatePermissionDescriptorClientMsgHandle{}
}

func (d *CreatePermissionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreatePermissionDescriptorServerMsgHandle{}
}

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

func (h *CreatePermissionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreatePermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreatePermissionRequest) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreatePermissionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreatePermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreatePermissionRequest) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetPermission()
	}
	return (*permission.Permission)(nil)
}

func (h *CreatePermissionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreatePermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreatePermissionRequest) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreatePermissionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*permission.Permission)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*permission.Permission) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreatePermissionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*permission.Permission)
}

func (h *CreatePermissionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*permission.Permission)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*permission.Permission) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreatePermissionDescriptor() *CreatePermissionDescriptor {
	return createPermissionDescriptor
}

type UpdatePermissionDescriptor struct{}

type UpdatePermissionDescriptorClientMsgHandle struct{}

type UpdatePermissionDescriptorServerMsgHandle struct{}

func (d *UpdatePermissionDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdatePermissionRequest{}
}

func (d *UpdatePermissionDescriptor) NewEmptyServerMsg() proto.Message {
	return &permission.Permission{}
}

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

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

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

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

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

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

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

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

func (d *UpdatePermissionDescriptor) GetMethodName() string {
	return "UpdatePermission"
}

func (d *UpdatePermissionDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.PermissionService/UpdatePermission"
}

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

func (d *UpdatePermissionDescriptor) GetApiName() string {
	return "PermissionService"
}

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

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

func (d *UpdatePermissionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return permissionServiceDescriptor
}

func (d *UpdatePermissionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return permission.GetDescriptor()
}

func (d *UpdatePermissionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdatePermissionDescriptorClientMsgHandle{}
}

func (d *UpdatePermissionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdatePermissionDescriptorServerMsgHandle{}
}

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

func (h *UpdatePermissionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdatePermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdatePermissionRequest) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdatePermissionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdatePermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdatePermissionRequest) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetPermission()
	}
	return (*permission.Permission)(nil)
}

func (h *UpdatePermissionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdatePermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdatePermissionRequest) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdatePermissionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*permission.Permission)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*permission.Permission) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdatePermissionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*permission.Permission)
}

func (h *UpdatePermissionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*permission.Permission)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*permission.Permission) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdatePermissionDescriptor() *UpdatePermissionDescriptor {
	return updatePermissionDescriptor
}

type DeletePermissionDescriptor struct{}

type DeletePermissionDescriptorClientMsgHandle struct{}

type DeletePermissionDescriptorServerMsgHandle struct{}

func (d *DeletePermissionDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeletePermissionRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeletePermissionDescriptor) GetMethodName() string {
	return "DeletePermission"
}

func (d *DeletePermissionDescriptor) GetFullMethodName() string {
	return "/ntt.iam.v1alpha2.PermissionService/DeletePermission"
}

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

func (d *DeletePermissionDescriptor) GetApiName() string {
	return "PermissionService"
}

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

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

func (d *DeletePermissionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return permissionServiceDescriptor
}

func (d *DeletePermissionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return permission.GetDescriptor()
}

func (d *DeletePermissionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeletePermissionDescriptorClientMsgHandle{}
}

func (d *DeletePermissionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeletePermissionDescriptorServerMsgHandle{}
}

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

func (h *DeletePermissionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeletePermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeletePermissionRequest) []*permission.Name
	})
	if ok {
		return permission.PermissionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeletePermissionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeletePermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeletePermissionRequest) *permission.Permission
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeletePermissionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeletePermissionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeletePermissionRequest) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeletePermissionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*permission.Permission
	})
	if ok {
		return permission.PermissionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeletePermissionDescriptor() *DeletePermissionDescriptor {
	return deletePermissionDescriptor
}

type PermissionServiceDescriptor struct{}

func (d *PermissionServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getPermissionDescriptor,
		batchGetPermissionsDescriptor,
		listPermissionsDescriptor,
		watchPermissionDescriptor,
		watchPermissionsDescriptor,
		createPermissionDescriptor,
		updatePermissionDescriptor,
		deletePermissionDescriptor,
	}
}

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

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

func (d *PermissionServiceDescriptor) GetApiName() string {
	return "PermissionService"
}

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

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

func GetPermissionServiceDescriptor() *PermissionServiceDescriptor {
	return permissionServiceDescriptor
}

func initDescriptors() {
	permissionServiceDescriptor = &PermissionServiceDescriptor{}
	getPermissionDescriptor = &GetPermissionDescriptor{}
	batchGetPermissionsDescriptor = &BatchGetPermissionsDescriptor{}
	listPermissionsDescriptor = &ListPermissionsDescriptor{}
	watchPermissionDescriptor = &WatchPermissionDescriptor{}
	watchPermissionsDescriptor = &WatchPermissionsDescriptor{}
	createPermissionDescriptor = &CreatePermissionDescriptor{}
	updatePermissionDescriptor = &UpdatePermissionDescriptor{}
	deletePermissionDescriptor = &DeletePermissionDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(permissionServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getPermissionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetPermissionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listPermissionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPermissionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPermissionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createPermissionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updatePermissionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deletePermissionDescriptor)
}

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