port_forwarding_service_service.pb.descriptors.go

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

package port_forwarding_service_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 (
	port_forwarding_service "github.com/cloudwan/ztna-sdk/resources/v1alpha/port_forwarding_service"
	empty "github.com/golang/protobuf/ptypes/empty"
)

// 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 (
	_ = &empty.Empty{}
	_ = &port_forwarding_service.PortForwardingService{}
)

var (
	descriptorsInitialized                   bool
	portForwardingServiceServiceDescriptor   *PortForwardingServiceServiceDescriptor
	getPortForwardingServiceDescriptor       *GetPortForwardingServiceDescriptor
	batchGetPortForwardingServicesDescriptor *BatchGetPortForwardingServicesDescriptor
	listPortForwardingServicesDescriptor     *ListPortForwardingServicesDescriptor
	watchPortForwardingServiceDescriptor     *WatchPortForwardingServiceDescriptor
	watchPortForwardingServicesDescriptor    *WatchPortForwardingServicesDescriptor
	createPortForwardingServiceDescriptor    *CreatePortForwardingServiceDescriptor
	updatePortForwardingServiceDescriptor    *UpdatePortForwardingServiceDescriptor
	deletePortForwardingServiceDescriptor    *DeletePortForwardingServiceDescriptor
)

type GetPortForwardingServiceDescriptor struct{}

type GetPortForwardingServiceDescriptorClientMsgHandle struct{}

type GetPortForwardingServiceDescriptorServerMsgHandle struct{}

func (d *GetPortForwardingServiceDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetPortForwardingServiceRequest{}
}

func (d *GetPortForwardingServiceDescriptor) NewEmptyServerMsg() proto.Message {
	return &port_forwarding_service.PortForwardingService{}
}

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

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

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

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

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

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

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

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

func (d *GetPortForwardingServiceDescriptor) GetMethodName() string {
	return "GetPortForwardingService"
}

func (d *GetPortForwardingServiceDescriptor) GetFullMethodName() string {
	return "/ntt.ztna.v1alpha.PortForwardingServiceService/GetPortForwardingService"
}

func (d *GetPortForwardingServiceDescriptor) GetProtoPkgName() string {
	return "ntt.ztna.v1alpha"
}

func (d *GetPortForwardingServiceDescriptor) GetApiName() string {
	return "PortForwardingServiceService"
}

func (d *GetPortForwardingServiceDescriptor) GetServiceDomain() string {
	return "ztna.edgelq.com"
}

func (d *GetPortForwardingServiceDescriptor) GetServiceVersion() string {
	return "v1alpha"
}

func (d *GetPortForwardingServiceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return portForwardingServiceServiceDescriptor
}

func (d *GetPortForwardingServiceDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return port_forwarding_service.GetDescriptor()
}

func (d *GetPortForwardingServiceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetPortForwardingServiceDescriptorClientMsgHandle{}
}

func (d *GetPortForwardingServiceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetPortForwardingServiceDescriptorServerMsgHandle{}
}

func (h *GetPortForwardingServiceDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*GetPortForwardingServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*GetPortForwardingServiceRequest) *port_forwarding_service.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if ref := typedMsg.GetName(); ref != nil {
			return &ref.Name
		}
	}
	return (*port_forwarding_service.Name)(nil)
}

func (h *GetPortForwardingServiceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetPortForwardingServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetPortForwardingServiceRequest) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *GetPortForwardingServiceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*port_forwarding_service.PortForwardingService)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*port_forwarding_service.PortForwardingService) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetGetPortForwardingServiceDescriptor() *GetPortForwardingServiceDescriptor {
	return getPortForwardingServiceDescriptor
}

type BatchGetPortForwardingServicesDescriptor struct{}

type BatchGetPortForwardingServicesDescriptorClientMsgHandle struct{}

type BatchGetPortForwardingServicesDescriptorServerMsgHandle struct{}

func (d *BatchGetPortForwardingServicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetPortForwardingServicesRequest{}
}

func (d *BatchGetPortForwardingServicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetPortForwardingServicesResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetPortForwardingServicesDescriptor) GetMethodName() string {
	return "BatchGetPortForwardingServices"
}

func (d *BatchGetPortForwardingServicesDescriptor) GetFullMethodName() string {
	return "/ntt.ztna.v1alpha.PortForwardingServiceService/BatchGetPortForwardingServices"
}

func (d *BatchGetPortForwardingServicesDescriptor) GetProtoPkgName() string {
	return "ntt.ztna.v1alpha"
}

func (d *BatchGetPortForwardingServicesDescriptor) GetApiName() string {
	return "PortForwardingServiceService"
}

func (d *BatchGetPortForwardingServicesDescriptor) GetServiceDomain() string {
	return "ztna.edgelq.com"
}

func (d *BatchGetPortForwardingServicesDescriptor) GetServiceVersion() string {
	return "v1alpha"
}

func (d *BatchGetPortForwardingServicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return portForwardingServiceServiceDescriptor
}

func (d *BatchGetPortForwardingServicesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return port_forwarding_service.GetDescriptor()
}

func (d *BatchGetPortForwardingServicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetPortForwardingServicesDescriptorClientMsgHandle{}
}

func (d *BatchGetPortForwardingServicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetPortForwardingServicesDescriptorServerMsgHandle{}
}

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

func (h *BatchGetPortForwardingServicesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BatchGetPortForwardingServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BatchGetPortForwardingServicesRequest) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if refs := typedMsg.GetNames(); len(refs) > 0 {
			list := make(port_forwarding_service.PortForwardingServiceNameList, 0, len(refs))
			for _, ref := range refs {
				list = append(list, &ref.Name)
			}
			return list
		}
	}
	return (port_forwarding_service.PortForwardingServiceNameList)(nil)
}

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

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

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

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

func GetBatchGetPortForwardingServicesDescriptor() *BatchGetPortForwardingServicesDescriptor {
	return batchGetPortForwardingServicesDescriptor
}

type ListPortForwardingServicesDescriptor struct{}

type ListPortForwardingServicesDescriptorClientMsgHandle struct{}

type ListPortForwardingServicesDescriptorServerMsgHandle struct{}

func (d *ListPortForwardingServicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListPortForwardingServicesRequest{}
}

func (d *ListPortForwardingServicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListPortForwardingServicesResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListPortForwardingServicesDescriptor) GetMethodName() string {
	return "ListPortForwardingServices"
}

func (d *ListPortForwardingServicesDescriptor) GetFullMethodName() string {
	return "/ntt.ztna.v1alpha.PortForwardingServiceService/ListPortForwardingServices"
}

func (d *ListPortForwardingServicesDescriptor) GetProtoPkgName() string {
	return "ntt.ztna.v1alpha"
}

func (d *ListPortForwardingServicesDescriptor) GetApiName() string {
	return "PortForwardingServiceService"
}

func (d *ListPortForwardingServicesDescriptor) GetServiceDomain() string {
	return "ztna.edgelq.com"
}

func (d *ListPortForwardingServicesDescriptor) GetServiceVersion() string {
	return "v1alpha"
}

func (d *ListPortForwardingServicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return portForwardingServiceServiceDescriptor
}

func (d *ListPortForwardingServicesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return port_forwarding_service.GetDescriptor()
}

func (d *ListPortForwardingServicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListPortForwardingServicesDescriptorClientMsgHandle{}
}

func (d *ListPortForwardingServicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListPortForwardingServicesDescriptorServerMsgHandle{}
}

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

func (h *ListPortForwardingServicesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListPortForwardingServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListPortForwardingServicesRequest) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

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

func GetListPortForwardingServicesDescriptor() *ListPortForwardingServicesDescriptor {
	return listPortForwardingServicesDescriptor
}

type WatchPortForwardingServiceDescriptor struct{}

type WatchPortForwardingServiceDescriptorClientMsgHandle struct{}

type WatchPortForwardingServiceDescriptorServerMsgHandle struct{}

func (d *WatchPortForwardingServiceDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchPortForwardingServiceRequest{}
}

func (d *WatchPortForwardingServiceDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchPortForwardingServiceResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchPortForwardingServiceDescriptor) GetMethodName() string {
	return "WatchPortForwardingService"
}

func (d *WatchPortForwardingServiceDescriptor) GetFullMethodName() string {
	return "/ntt.ztna.v1alpha.PortForwardingServiceService/WatchPortForwardingService"
}

func (d *WatchPortForwardingServiceDescriptor) GetProtoPkgName() string {
	return "ntt.ztna.v1alpha"
}

func (d *WatchPortForwardingServiceDescriptor) GetApiName() string {
	return "PortForwardingServiceService"
}

func (d *WatchPortForwardingServiceDescriptor) GetServiceDomain() string {
	return "ztna.edgelq.com"
}

func (d *WatchPortForwardingServiceDescriptor) GetServiceVersion() string {
	return "v1alpha"
}

func (d *WatchPortForwardingServiceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return portForwardingServiceServiceDescriptor
}

func (d *WatchPortForwardingServiceDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return port_forwarding_service.GetDescriptor()
}

func (d *WatchPortForwardingServiceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPortForwardingServiceDescriptorClientMsgHandle{}
}

func (d *WatchPortForwardingServiceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPortForwardingServiceDescriptorServerMsgHandle{}
}

func (h *WatchPortForwardingServiceDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchPortForwardingServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchPortForwardingServiceRequest) *port_forwarding_service.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if ref := typedMsg.GetName(); ref != nil {
			return &ref.Name
		}
	}
	return (*port_forwarding_service.Name)(nil)
}

func (h *WatchPortForwardingServiceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPortForwardingServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPortForwardingServiceRequest) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchPortForwardingServiceDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchPortForwardingServiceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchPortForwardingServiceResponse) *port_forwarding_service.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *port_forwarding_service.PortForwardingServiceChange_Added_:
				return tResChange.Added.GetPortForwardingService().GetName()
			case *port_forwarding_service.PortForwardingServiceChange_Modified_:
				return tResChange.Modified.GetName()
			case *port_forwarding_service.PortForwardingServiceChange_Removed_:
				return tResChange.Removed.GetName()
			case *port_forwarding_service.PortForwardingServiceChange_Current_:
				return tResChange.Current.GetPortForwardingService().GetName()
			}
		}
	}
	return (*port_forwarding_service.Name)(nil)
}

func (h *WatchPortForwardingServiceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPortForwardingServiceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPortForwardingServiceResponse) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetWatchPortForwardingServiceDescriptor() *WatchPortForwardingServiceDescriptor {
	return watchPortForwardingServiceDescriptor
}

type WatchPortForwardingServicesDescriptor struct{}

type WatchPortForwardingServicesDescriptorClientMsgHandle struct{}

type WatchPortForwardingServicesDescriptorServerMsgHandle struct{}

func (d *WatchPortForwardingServicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchPortForwardingServicesRequest{}
}

func (d *WatchPortForwardingServicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchPortForwardingServicesResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchPortForwardingServicesDescriptor) GetMethodName() string {
	return "WatchPortForwardingServices"
}

func (d *WatchPortForwardingServicesDescriptor) GetFullMethodName() string {
	return "/ntt.ztna.v1alpha.PortForwardingServiceService/WatchPortForwardingServices"
}

func (d *WatchPortForwardingServicesDescriptor) GetProtoPkgName() string {
	return "ntt.ztna.v1alpha"
}

func (d *WatchPortForwardingServicesDescriptor) GetApiName() string {
	return "PortForwardingServiceService"
}

func (d *WatchPortForwardingServicesDescriptor) GetServiceDomain() string {
	return "ztna.edgelq.com"
}

func (d *WatchPortForwardingServicesDescriptor) GetServiceVersion() string {
	return "v1alpha"
}

func (d *WatchPortForwardingServicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return portForwardingServiceServiceDescriptor
}

func (d *WatchPortForwardingServicesDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return port_forwarding_service.GetDescriptor()
}

func (d *WatchPortForwardingServicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPortForwardingServicesDescriptorClientMsgHandle{}
}

func (d *WatchPortForwardingServicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchPortForwardingServicesDescriptorServerMsgHandle{}
}

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

func (h *WatchPortForwardingServicesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPortForwardingServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPortForwardingServicesRequest) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchPortForwardingServicesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchPortForwardingServicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*WatchPortForwardingServicesRequest) *port_forwarding_service.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if ref := typedMsg.GetParent(); ref != nil {
			return &ref.ParentName
		}
	}
	return (*port_forwarding_service.ParentName)(nil)
}

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

func (h *WatchPortForwardingServicesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchPortForwardingServicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchPortForwardingServicesResponse) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetPortForwardingServiceChanges(); len(resChanges) > 0 {
			list := make(port_forwarding_service.PortForwardingServiceNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *port_forwarding_service.PortForwardingServiceChange_Added_:
					list = append(list, tResChange.Added.GetPortForwardingService().GetName())
				case *port_forwarding_service.PortForwardingServiceChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *port_forwarding_service.PortForwardingServiceChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *port_forwarding_service.PortForwardingServiceChange_Current_:
					list = append(list, tResChange.Current.GetPortForwardingService().GetName())
				}
			}
			return list
		}
	}
	return (port_forwarding_service.PortForwardingServiceNameList)(nil)
}

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

func GetWatchPortForwardingServicesDescriptor() *WatchPortForwardingServicesDescriptor {
	return watchPortForwardingServicesDescriptor
}

type CreatePortForwardingServiceDescriptor struct{}

type CreatePortForwardingServiceDescriptorClientMsgHandle struct{}

type CreatePortForwardingServiceDescriptorServerMsgHandle struct{}

func (d *CreatePortForwardingServiceDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreatePortForwardingServiceRequest{}
}

func (d *CreatePortForwardingServiceDescriptor) NewEmptyServerMsg() proto.Message {
	return &port_forwarding_service.PortForwardingService{}
}

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

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

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

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

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

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

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

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

func (d *CreatePortForwardingServiceDescriptor) GetMethodName() string {
	return "CreatePortForwardingService"
}

func (d *CreatePortForwardingServiceDescriptor) GetFullMethodName() string {
	return "/ntt.ztna.v1alpha.PortForwardingServiceService/CreatePortForwardingService"
}

func (d *CreatePortForwardingServiceDescriptor) GetProtoPkgName() string {
	return "ntt.ztna.v1alpha"
}

func (d *CreatePortForwardingServiceDescriptor) GetApiName() string {
	return "PortForwardingServiceService"
}

func (d *CreatePortForwardingServiceDescriptor) GetServiceDomain() string {
	return "ztna.edgelq.com"
}

func (d *CreatePortForwardingServiceDescriptor) GetServiceVersion() string {
	return "v1alpha"
}

func (d *CreatePortForwardingServiceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return portForwardingServiceServiceDescriptor
}

func (d *CreatePortForwardingServiceDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return port_forwarding_service.GetDescriptor()
}

func (d *CreatePortForwardingServiceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreatePortForwardingServiceDescriptorClientMsgHandle{}
}

func (d *CreatePortForwardingServiceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreatePortForwardingServiceDescriptorServerMsgHandle{}
}

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

func (h *CreatePortForwardingServiceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreatePortForwardingServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreatePortForwardingServiceRequest) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreatePortForwardingServiceDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreatePortForwardingServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*CreatePortForwardingServiceRequest) *port_forwarding_service.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if ref := typedMsg.GetParent(); ref != nil {
			return &ref.ParentName
		}
	}
	return (*port_forwarding_service.ParentName)(nil)
}

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

func (h *CreatePortForwardingServiceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*port_forwarding_service.PortForwardingService)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*port_forwarding_service.PortForwardingService) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetCreatePortForwardingServiceDescriptor() *CreatePortForwardingServiceDescriptor {
	return createPortForwardingServiceDescriptor
}

type UpdatePortForwardingServiceDescriptor struct{}

type UpdatePortForwardingServiceDescriptorClientMsgHandle struct{}

type UpdatePortForwardingServiceDescriptorServerMsgHandle struct{}

func (d *UpdatePortForwardingServiceDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdatePortForwardingServiceRequest{}
}

func (d *UpdatePortForwardingServiceDescriptor) NewEmptyServerMsg() proto.Message {
	return &port_forwarding_service.PortForwardingService{}
}

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

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

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

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

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

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

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

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

func (d *UpdatePortForwardingServiceDescriptor) GetMethodName() string {
	return "UpdatePortForwardingService"
}

func (d *UpdatePortForwardingServiceDescriptor) GetFullMethodName() string {
	return "/ntt.ztna.v1alpha.PortForwardingServiceService/UpdatePortForwardingService"
}

func (d *UpdatePortForwardingServiceDescriptor) GetProtoPkgName() string {
	return "ntt.ztna.v1alpha"
}

func (d *UpdatePortForwardingServiceDescriptor) GetApiName() string {
	return "PortForwardingServiceService"
}

func (d *UpdatePortForwardingServiceDescriptor) GetServiceDomain() string {
	return "ztna.edgelq.com"
}

func (d *UpdatePortForwardingServiceDescriptor) GetServiceVersion() string {
	return "v1alpha"
}

func (d *UpdatePortForwardingServiceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return portForwardingServiceServiceDescriptor
}

func (d *UpdatePortForwardingServiceDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return port_forwarding_service.GetDescriptor()
}

func (d *UpdatePortForwardingServiceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdatePortForwardingServiceDescriptorClientMsgHandle{}
}

func (d *UpdatePortForwardingServiceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdatePortForwardingServiceDescriptorServerMsgHandle{}
}

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

func (h *UpdatePortForwardingServiceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdatePortForwardingServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdatePortForwardingServiceRequest) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *UpdatePortForwardingServiceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*port_forwarding_service.PortForwardingService)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*port_forwarding_service.PortForwardingService) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetUpdatePortForwardingServiceDescriptor() *UpdatePortForwardingServiceDescriptor {
	return updatePortForwardingServiceDescriptor
}

type DeletePortForwardingServiceDescriptor struct{}

type DeletePortForwardingServiceDescriptorClientMsgHandle struct{}

type DeletePortForwardingServiceDescriptorServerMsgHandle struct{}

func (d *DeletePortForwardingServiceDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeletePortForwardingServiceRequest{}
}

func (d *DeletePortForwardingServiceDescriptor) NewEmptyServerMsg() proto.Message {
	return &empty.Empty{}
}

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

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

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

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

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

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

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

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

func (d *DeletePortForwardingServiceDescriptor) GetMethodName() string {
	return "DeletePortForwardingService"
}

func (d *DeletePortForwardingServiceDescriptor) GetFullMethodName() string {
	return "/ntt.ztna.v1alpha.PortForwardingServiceService/DeletePortForwardingService"
}

func (d *DeletePortForwardingServiceDescriptor) GetProtoPkgName() string {
	return "ntt.ztna.v1alpha"
}

func (d *DeletePortForwardingServiceDescriptor) GetApiName() string {
	return "PortForwardingServiceService"
}

func (d *DeletePortForwardingServiceDescriptor) GetServiceDomain() string {
	return "ztna.edgelq.com"
}

func (d *DeletePortForwardingServiceDescriptor) GetServiceVersion() string {
	return "v1alpha"
}

func (d *DeletePortForwardingServiceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return portForwardingServiceServiceDescriptor
}

func (d *DeletePortForwardingServiceDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return port_forwarding_service.GetDescriptor()
}

func (d *DeletePortForwardingServiceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeletePortForwardingServiceDescriptorClientMsgHandle{}
}

func (d *DeletePortForwardingServiceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeletePortForwardingServiceDescriptorServerMsgHandle{}
}

func (h *DeletePortForwardingServiceDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*DeletePortForwardingServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*DeletePortForwardingServiceRequest) *port_forwarding_service.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if ref := typedMsg.GetName(); ref != nil {
			return &ref.Name
		}
	}
	return (*port_forwarding_service.Name)(nil)
}

func (h *DeletePortForwardingServiceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeletePortForwardingServiceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeletePortForwardingServiceRequest) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *DeletePortForwardingServiceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*empty.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*empty.Empty) []*port_forwarding_service.Name
	})
	if ok {
		return port_forwarding_service.PortForwardingServiceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetDeletePortForwardingServiceDescriptor() *DeletePortForwardingServiceDescriptor {
	return deletePortForwardingServiceDescriptor
}

type PortForwardingServiceServiceDescriptor struct{}

func (d *PortForwardingServiceServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getPortForwardingServiceDescriptor,
		batchGetPortForwardingServicesDescriptor,
		listPortForwardingServicesDescriptor,
		watchPortForwardingServiceDescriptor,
		watchPortForwardingServicesDescriptor,
		createPortForwardingServiceDescriptor,
		updatePortForwardingServiceDescriptor,
		deletePortForwardingServiceDescriptor,
	}
}

func (d *PortForwardingServiceServiceDescriptor) GetFullAPIName() string {
	return "/ntt.ztna.v1alpha.PortForwardingServiceService"
}

func (d *PortForwardingServiceServiceDescriptor) GetProtoPkgName() string {
	return "ntt.ztna.v1alpha"
}

func (d *PortForwardingServiceServiceDescriptor) GetApiName() string {
	return "PortForwardingServiceService"
}

func (d *PortForwardingServiceServiceDescriptor) GetServiceDomain() string {
	return "ztna.edgelq.com"
}

func (d *PortForwardingServiceServiceDescriptor) GetServiceVersion() string {
	return "v1alpha"
}

func GetPortForwardingServiceServiceDescriptor() *PortForwardingServiceServiceDescriptor {
	return portForwardingServiceServiceDescriptor
}

func initDescriptors() {
	portForwardingServiceServiceDescriptor = &PortForwardingServiceServiceDescriptor{}
	getPortForwardingServiceDescriptor = &GetPortForwardingServiceDescriptor{}
	batchGetPortForwardingServicesDescriptor = &BatchGetPortForwardingServicesDescriptor{}
	listPortForwardingServicesDescriptor = &ListPortForwardingServicesDescriptor{}
	watchPortForwardingServiceDescriptor = &WatchPortForwardingServiceDescriptor{}
	watchPortForwardingServicesDescriptor = &WatchPortForwardingServicesDescriptor{}
	createPortForwardingServiceDescriptor = &CreatePortForwardingServiceDescriptor{}
	updatePortForwardingServiceDescriptor = &UpdatePortForwardingServiceDescriptor{}
	deletePortForwardingServiceDescriptor = &DeletePortForwardingServiceDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(portForwardingServiceServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getPortForwardingServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetPortForwardingServicesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listPortForwardingServicesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPortForwardingServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPortForwardingServicesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createPortForwardingServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updatePortForwardingServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deletePortForwardingServiceDescriptor)
}

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