log_descriptor_service.pb.descriptors.go

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

package log_descriptor_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 (
	log_descriptor "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log_descriptor"
	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 (
	_ = &log_descriptor.LogDescriptor{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized           bool
	logDescriptorServiceDescriptor   *LogDescriptorServiceDescriptor
	getLogDescriptorDescriptor       *GetLogDescriptorDescriptor
	batchGetLogDescriptorsDescriptor *BatchGetLogDescriptorsDescriptor
	listLogDescriptorsDescriptor     *ListLogDescriptorsDescriptor
	watchLogDescriptorDescriptor     *WatchLogDescriptorDescriptor
	watchLogDescriptorsDescriptor    *WatchLogDescriptorsDescriptor
	createLogDescriptorDescriptor    *CreateLogDescriptorDescriptor
	updateLogDescriptorDescriptor    *UpdateLogDescriptorDescriptor
	deleteLogDescriptorDescriptor    *DeleteLogDescriptorDescriptor
)

type GetLogDescriptorDescriptor struct{}

type GetLogDescriptorDescriptorClientMsgHandle struct{}

type GetLogDescriptorDescriptorServerMsgHandle struct{}

func (d *GetLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetLogDescriptorRequest{}
}

func (d *GetLogDescriptorDescriptor) NewEmptyServerMsg() proto.Message {
	return &log_descriptor.LogDescriptor{}
}

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

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

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

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

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

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

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

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

func (d *GetLogDescriptorDescriptor) GetMethodName() string {
	return "GetLogDescriptor"
}

func (d *GetLogDescriptorDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogDescriptorService/GetLogDescriptor"
}

func (d *GetLogDescriptorDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *GetLogDescriptorDescriptor) GetApiName() string {
	return "LogDescriptorService"
}

func (d *GetLogDescriptorDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

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

func (d *GetLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logDescriptorServiceDescriptor
}

func (d *GetLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log_descriptor.GetDescriptor()
}

func (d *GetLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetLogDescriptorDescriptorClientMsgHandle{}
}

func (d *GetLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetLogDescriptorDescriptorServerMsgHandle{}
}

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

func (h *GetLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetLogDescriptorRequest) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetLogDescriptorRequest) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetLogDescriptorRequest) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetLogDescriptorDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*log_descriptor.LogDescriptor)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*log_descriptor.LogDescriptor) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetLogDescriptorDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*log_descriptor.LogDescriptor)
}

func (h *GetLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*log_descriptor.LogDescriptor)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*log_descriptor.LogDescriptor) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetLogDescriptorDescriptor() *GetLogDescriptorDescriptor {
	return getLogDescriptorDescriptor
}

type BatchGetLogDescriptorsDescriptor struct{}

type BatchGetLogDescriptorsDescriptorClientMsgHandle struct{}

type BatchGetLogDescriptorsDescriptorServerMsgHandle struct{}

func (d *BatchGetLogDescriptorsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetLogDescriptorsRequest{}
}

func (d *BatchGetLogDescriptorsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetLogDescriptorsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetLogDescriptorsDescriptor) GetMethodName() string {
	return "BatchGetLogDescriptors"
}

func (d *BatchGetLogDescriptorsDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogDescriptorService/BatchGetLogDescriptors"
}

func (d *BatchGetLogDescriptorsDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *BatchGetLogDescriptorsDescriptor) GetApiName() string {
	return "LogDescriptorService"
}

func (d *BatchGetLogDescriptorsDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

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

func (d *BatchGetLogDescriptorsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logDescriptorServiceDescriptor
}

func (d *BatchGetLogDescriptorsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log_descriptor.GetDescriptor()
}

func (d *BatchGetLogDescriptorsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetLogDescriptorsDescriptorClientMsgHandle{}
}

func (d *BatchGetLogDescriptorsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetLogDescriptorsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetLogDescriptorsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetLogDescriptorsRequest) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetLogDescriptorsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetLogDescriptorsRequest) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetLogDescriptorsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetLogDescriptorsResponse) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetLogDescriptorsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetLogDescriptorsResponse) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetLogDescriptors(); len(resources) > 0 {
			return log_descriptor.LogDescriptorList(resources)
		}
	}
	return (log_descriptor.LogDescriptorList)(nil)
}

func GetBatchGetLogDescriptorsDescriptor() *BatchGetLogDescriptorsDescriptor {
	return batchGetLogDescriptorsDescriptor
}

type ListLogDescriptorsDescriptor struct{}

type ListLogDescriptorsDescriptorClientMsgHandle struct{}

type ListLogDescriptorsDescriptorServerMsgHandle struct{}

func (d *ListLogDescriptorsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListLogDescriptorsRequest{}
}

func (d *ListLogDescriptorsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListLogDescriptorsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListLogDescriptorsDescriptor) GetMethodName() string {
	return "ListLogDescriptors"
}

func (d *ListLogDescriptorsDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogDescriptorService/ListLogDescriptors"
}

func (d *ListLogDescriptorsDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *ListLogDescriptorsDescriptor) GetApiName() string {
	return "LogDescriptorService"
}

func (d *ListLogDescriptorsDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

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

func (d *ListLogDescriptorsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logDescriptorServiceDescriptor
}

func (d *ListLogDescriptorsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log_descriptor.GetDescriptor()
}

func (d *ListLogDescriptorsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListLogDescriptorsDescriptorClientMsgHandle{}
}

func (d *ListLogDescriptorsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListLogDescriptorsDescriptorServerMsgHandle{}
}

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

func (h *ListLogDescriptorsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListLogDescriptorsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListLogDescriptorsRequest) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListLogDescriptorsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListLogDescriptorsRequest) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListLogDescriptorsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListLogDescriptorsRequest) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListLogDescriptorsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListLogDescriptorsResponse) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListLogDescriptorsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListLogDescriptorsResponse) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetLogDescriptors(); len(resources) > 0 {
			return log_descriptor.LogDescriptorList(resources)
		}
	}
	return (log_descriptor.LogDescriptorList)(nil)
}

func GetListLogDescriptorsDescriptor() *ListLogDescriptorsDescriptor {
	return listLogDescriptorsDescriptor
}

type WatchLogDescriptorDescriptor struct{}

type WatchLogDescriptorDescriptorClientMsgHandle struct{}

type WatchLogDescriptorDescriptorServerMsgHandle struct{}

func (d *WatchLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchLogDescriptorRequest{}
}

func (d *WatchLogDescriptorDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchLogDescriptorResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchLogDescriptorDescriptor) GetMethodName() string {
	return "WatchLogDescriptor"
}

func (d *WatchLogDescriptorDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogDescriptorService/WatchLogDescriptor"
}

func (d *WatchLogDescriptorDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *WatchLogDescriptorDescriptor) GetApiName() string {
	return "LogDescriptorService"
}

func (d *WatchLogDescriptorDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

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

func (d *WatchLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logDescriptorServiceDescriptor
}

func (d *WatchLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log_descriptor.GetDescriptor()
}

func (d *WatchLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchLogDescriptorDescriptorClientMsgHandle{}
}

func (d *WatchLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchLogDescriptorDescriptorServerMsgHandle{}
}

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

func (h *WatchLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchLogDescriptorRequest) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchLogDescriptorRequest) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchLogDescriptorRequest) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchLogDescriptorDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchLogDescriptorResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchLogDescriptorResponse) *log_descriptor.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *log_descriptor.LogDescriptorChange_Added_:
				return tResChange.Added.GetLogDescriptor().GetName()
			case *log_descriptor.LogDescriptorChange_Modified_:
				return tResChange.Modified.GetName()
			case *log_descriptor.LogDescriptorChange_Removed_:
				return tResChange.Removed.GetName()
			case *log_descriptor.LogDescriptorChange_Current_:
				return tResChange.Current.GetLogDescriptor().GetName()
			}
		}
	}
	return (*log_descriptor.Name)(nil)
}

func (h *WatchLogDescriptorDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchLogDescriptorResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchLogDescriptorResponse) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchLogDescriptorDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchLogDescriptorResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchLogDescriptorResponse) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *log_descriptor.LogDescriptorChange_Added_:
				return tResChange.Added.GetLogDescriptor()
			case *log_descriptor.LogDescriptorChange_Modified_:
				return tResChange.Modified.GetLogDescriptor()
			case *log_descriptor.LogDescriptorChange_Current_:
				return tResChange.Current.GetLogDescriptor()
			}
		}
	}
	return (*log_descriptor.LogDescriptor)(nil)
}

func (h *WatchLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchLogDescriptorResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchLogDescriptorResponse) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchLogDescriptorDescriptor() *WatchLogDescriptorDescriptor {
	return watchLogDescriptorDescriptor
}

type WatchLogDescriptorsDescriptor struct{}

type WatchLogDescriptorsDescriptorClientMsgHandle struct{}

type WatchLogDescriptorsDescriptorServerMsgHandle struct{}

func (d *WatchLogDescriptorsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchLogDescriptorsRequest{}
}

func (d *WatchLogDescriptorsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchLogDescriptorsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchLogDescriptorsDescriptor) GetMethodName() string {
	return "WatchLogDescriptors"
}

func (d *WatchLogDescriptorsDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogDescriptorService/WatchLogDescriptors"
}

func (d *WatchLogDescriptorsDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *WatchLogDescriptorsDescriptor) GetApiName() string {
	return "LogDescriptorService"
}

func (d *WatchLogDescriptorsDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

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

func (d *WatchLogDescriptorsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logDescriptorServiceDescriptor
}

func (d *WatchLogDescriptorsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log_descriptor.GetDescriptor()
}

func (d *WatchLogDescriptorsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchLogDescriptorsDescriptorClientMsgHandle{}
}

func (d *WatchLogDescriptorsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchLogDescriptorsDescriptorServerMsgHandle{}
}

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

func (h *WatchLogDescriptorsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchLogDescriptorsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchLogDescriptorsRequest) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchLogDescriptorsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchLogDescriptorsRequest) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchLogDescriptorsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchLogDescriptorsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchLogDescriptorsRequest) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchLogDescriptorsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchLogDescriptorsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchLogDescriptorsResponse) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetLogDescriptorChanges(); len(resChanges) > 0 {
			list := make(log_descriptor.LogDescriptorNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *log_descriptor.LogDescriptorChange_Added_:
					list = append(list, tResChange.Added.GetLogDescriptor().GetName())
				case *log_descriptor.LogDescriptorChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *log_descriptor.LogDescriptorChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *log_descriptor.LogDescriptorChange_Current_:
					list = append(list, tResChange.Current.GetLogDescriptor().GetName())
				}
			}
			return list
		}
	}
	return (log_descriptor.LogDescriptorNameList)(nil)
}

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

func (h *WatchLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchLogDescriptorsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchLogDescriptorsResponse) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchLogDescriptorsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchLogDescriptorsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchLogDescriptorsResponse) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetLogDescriptorChanges(); len(resChanges) > 0 {
			list := make(log_descriptor.LogDescriptorList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *log_descriptor.LogDescriptorChange_Added_:
					list = append(list, tResChange.Added.GetLogDescriptor())
				case *log_descriptor.LogDescriptorChange_Modified_:
					list = append(list, tResChange.Modified.GetLogDescriptor())
				case *log_descriptor.LogDescriptorChange_Current_:
					list = append(list, tResChange.Current.GetLogDescriptor())
				}
			}
			return list
		}
	}
	return (log_descriptor.LogDescriptorList)(nil)
}

func GetWatchLogDescriptorsDescriptor() *WatchLogDescriptorsDescriptor {
	return watchLogDescriptorsDescriptor
}

type CreateLogDescriptorDescriptor struct{}

type CreateLogDescriptorDescriptorClientMsgHandle struct{}

type CreateLogDescriptorDescriptorServerMsgHandle struct{}

func (d *CreateLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateLogDescriptorRequest{}
}

func (d *CreateLogDescriptorDescriptor) NewEmptyServerMsg() proto.Message {
	return &log_descriptor.LogDescriptor{}
}

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

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

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

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

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

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

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

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

func (d *CreateLogDescriptorDescriptor) GetMethodName() string {
	return "CreateLogDescriptor"
}

func (d *CreateLogDescriptorDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogDescriptorService/CreateLogDescriptor"
}

func (d *CreateLogDescriptorDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *CreateLogDescriptorDescriptor) GetApiName() string {
	return "LogDescriptorService"
}

func (d *CreateLogDescriptorDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

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

func (d *CreateLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logDescriptorServiceDescriptor
}

func (d *CreateLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log_descriptor.GetDescriptor()
}

func (d *CreateLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateLogDescriptorDescriptorClientMsgHandle{}
}

func (d *CreateLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateLogDescriptorDescriptorServerMsgHandle{}
}

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

func (h *CreateLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateLogDescriptorRequest) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateLogDescriptorRequest) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetLogDescriptor()
	}
	return (*log_descriptor.LogDescriptor)(nil)
}

func (h *CreateLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateLogDescriptorRequest) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateLogDescriptorDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*log_descriptor.LogDescriptor)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*log_descriptor.LogDescriptor) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateLogDescriptorDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*log_descriptor.LogDescriptor)
}

func (h *CreateLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*log_descriptor.LogDescriptor)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*log_descriptor.LogDescriptor) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateLogDescriptorDescriptor() *CreateLogDescriptorDescriptor {
	return createLogDescriptorDescriptor
}

type UpdateLogDescriptorDescriptor struct{}

type UpdateLogDescriptorDescriptorClientMsgHandle struct{}

type UpdateLogDescriptorDescriptorServerMsgHandle struct{}

func (d *UpdateLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateLogDescriptorRequest{}
}

func (d *UpdateLogDescriptorDescriptor) NewEmptyServerMsg() proto.Message {
	return &log_descriptor.LogDescriptor{}
}

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

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

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

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

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

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

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

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

func (d *UpdateLogDescriptorDescriptor) GetMethodName() string {
	return "UpdateLogDescriptor"
}

func (d *UpdateLogDescriptorDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogDescriptorService/UpdateLogDescriptor"
}

func (d *UpdateLogDescriptorDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *UpdateLogDescriptorDescriptor) GetApiName() string {
	return "LogDescriptorService"
}

func (d *UpdateLogDescriptorDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

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

func (d *UpdateLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logDescriptorServiceDescriptor
}

func (d *UpdateLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log_descriptor.GetDescriptor()
}

func (d *UpdateLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateLogDescriptorDescriptorClientMsgHandle{}
}

func (d *UpdateLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateLogDescriptorDescriptorServerMsgHandle{}
}

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

func (h *UpdateLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateLogDescriptorRequest) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateLogDescriptorRequest) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetLogDescriptor()
	}
	return (*log_descriptor.LogDescriptor)(nil)
}

func (h *UpdateLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateLogDescriptorRequest) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateLogDescriptorDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*log_descriptor.LogDescriptor)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*log_descriptor.LogDescriptor) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateLogDescriptorDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*log_descriptor.LogDescriptor)
}

func (h *UpdateLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*log_descriptor.LogDescriptor)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*log_descriptor.LogDescriptor) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateLogDescriptorDescriptor() *UpdateLogDescriptorDescriptor {
	return updateLogDescriptorDescriptor
}

type DeleteLogDescriptorDescriptor struct{}

type DeleteLogDescriptorDescriptorClientMsgHandle struct{}

type DeleteLogDescriptorDescriptorServerMsgHandle struct{}

func (d *DeleteLogDescriptorDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteLogDescriptorRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteLogDescriptorDescriptor) GetMethodName() string {
	return "DeleteLogDescriptor"
}

func (d *DeleteLogDescriptorDescriptor) GetFullMethodName() string {
	return "/ntt.logging.v1.LogDescriptorService/DeleteLogDescriptor"
}

func (d *DeleteLogDescriptorDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *DeleteLogDescriptorDescriptor) GetApiName() string {
	return "LogDescriptorService"
}

func (d *DeleteLogDescriptorDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

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

func (d *DeleteLogDescriptorDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return logDescriptorServiceDescriptor
}

func (d *DeleteLogDescriptorDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return log_descriptor.GetDescriptor()
}

func (d *DeleteLogDescriptorDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteLogDescriptorDescriptorClientMsgHandle{}
}

func (d *DeleteLogDescriptorDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteLogDescriptorDescriptorServerMsgHandle{}
}

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

func (h *DeleteLogDescriptorDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteLogDescriptorRequest) []*log_descriptor.Name
	})
	if ok {
		return log_descriptor.LogDescriptorNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteLogDescriptorDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteLogDescriptorRequest) *log_descriptor.LogDescriptor
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteLogDescriptorDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteLogDescriptorRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteLogDescriptorRequest) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteLogDescriptorDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*log_descriptor.LogDescriptor
	})
	if ok {
		return log_descriptor.LogDescriptorList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteLogDescriptorDescriptor() *DeleteLogDescriptorDescriptor {
	return deleteLogDescriptorDescriptor
}

type LogDescriptorServiceDescriptor struct{}

func (d *LogDescriptorServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getLogDescriptorDescriptor,
		batchGetLogDescriptorsDescriptor,
		listLogDescriptorsDescriptor,
		watchLogDescriptorDescriptor,
		watchLogDescriptorsDescriptor,
		createLogDescriptorDescriptor,
		updateLogDescriptorDescriptor,
		deleteLogDescriptorDescriptor,
	}
}

func (d *LogDescriptorServiceDescriptor) GetFullAPIName() string {
	return "/ntt.logging.v1.LogDescriptorService"
}

func (d *LogDescriptorServiceDescriptor) GetProtoPkgName() string {
	return "ntt.logging.v1"
}

func (d *LogDescriptorServiceDescriptor) GetApiName() string {
	return "LogDescriptorService"
}

func (d *LogDescriptorServiceDescriptor) GetServiceDomain() string {
	return "logging.edgelq.com"
}

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

func GetLogDescriptorServiceDescriptor() *LogDescriptorServiceDescriptor {
	return logDescriptorServiceDescriptor
}

func initDescriptors() {
	logDescriptorServiceDescriptor = &LogDescriptorServiceDescriptor{}
	getLogDescriptorDescriptor = &GetLogDescriptorDescriptor{}
	batchGetLogDescriptorsDescriptor = &BatchGetLogDescriptorsDescriptor{}
	listLogDescriptorsDescriptor = &ListLogDescriptorsDescriptor{}
	watchLogDescriptorDescriptor = &WatchLogDescriptorDescriptor{}
	watchLogDescriptorsDescriptor = &WatchLogDescriptorsDescriptor{}
	createLogDescriptorDescriptor = &CreateLogDescriptorDescriptor{}
	updateLogDescriptorDescriptor = &UpdateLogDescriptorDescriptor{}
	deleteLogDescriptorDescriptor = &DeleteLogDescriptorDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(logDescriptorServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getLogDescriptorDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetLogDescriptorsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listLogDescriptorsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchLogDescriptorDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchLogDescriptorsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createLogDescriptorDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateLogDescriptorDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteLogDescriptorDescriptor)
}

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