bucket_service.pb.descriptors.go

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

package bucket_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 (
	bucket "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/bucket"
	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 (
	_ = &bucket.Bucket{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized    bool
	bucketServiceDescriptor   *BucketServiceDescriptor
	getBucketDescriptor       *GetBucketDescriptor
	batchGetBucketsDescriptor *BatchGetBucketsDescriptor
	listBucketsDescriptor     *ListBucketsDescriptor
	watchBucketDescriptor     *WatchBucketDescriptor
	watchBucketsDescriptor    *WatchBucketsDescriptor
	createBucketDescriptor    *CreateBucketDescriptor
	updateBucketDescriptor    *UpdateBucketDescriptor
	deleteBucketDescriptor    *DeleteBucketDescriptor
)

type GetBucketDescriptor struct{}

type GetBucketDescriptorClientMsgHandle struct{}

type GetBucketDescriptorServerMsgHandle struct{}

func (d *GetBucketDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetBucketRequest{}
}

func (d *GetBucketDescriptor) NewEmptyServerMsg() proto.Message {
	return &bucket.Bucket{}
}

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

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

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

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

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

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

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

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

func (d *GetBucketDescriptor) GetMethodName() string {
	return "GetBucket"
}

func (d *GetBucketDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.BucketService/GetBucket"
}

func (d *GetBucketDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *GetBucketDescriptor) GetApiName() string {
	return "BucketService"
}

func (d *GetBucketDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *GetBucketDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *GetBucketDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return bucketServiceDescriptor
}

func (d *GetBucketDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return bucket.GetDescriptor()
}

func (d *GetBucketDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetBucketDescriptorClientMsgHandle{}
}

func (d *GetBucketDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetBucketDescriptorServerMsgHandle{}
}

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

func (h *GetBucketDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetBucketRequest) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetBucketDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetBucketRequest) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetBucketDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetBucketRequest) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetBucketDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*bucket.Bucket)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*bucket.Bucket) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetBucketDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*bucket.Bucket)
}

func (h *GetBucketDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*bucket.Bucket)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*bucket.Bucket) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetBucketDescriptor() *GetBucketDescriptor {
	return getBucketDescriptor
}

type BatchGetBucketsDescriptor struct{}

type BatchGetBucketsDescriptorClientMsgHandle struct{}

type BatchGetBucketsDescriptorServerMsgHandle struct{}

func (d *BatchGetBucketsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetBucketsRequest{}
}

func (d *BatchGetBucketsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetBucketsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetBucketsDescriptor) GetMethodName() string {
	return "BatchGetBuckets"
}

func (d *BatchGetBucketsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.BucketService/BatchGetBuckets"
}

func (d *BatchGetBucketsDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *BatchGetBucketsDescriptor) GetApiName() string {
	return "BucketService"
}

func (d *BatchGetBucketsDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *BatchGetBucketsDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *BatchGetBucketsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return bucketServiceDescriptor
}

func (d *BatchGetBucketsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return bucket.GetDescriptor()
}

func (d *BatchGetBucketsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetBucketsDescriptorClientMsgHandle{}
}

func (d *BatchGetBucketsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetBucketsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetBucketsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetBucketsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetBucketsRequest) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetBucketsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetBucketsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetBucketsRequest) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetBucketsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetBucketsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetBucketsResponse) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetBucketsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetBucketsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetBucketsResponse) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetBuckets(); len(resources) > 0 {
			return bucket.BucketList(resources)
		}
	}
	return (bucket.BucketList)(nil)
}

func GetBatchGetBucketsDescriptor() *BatchGetBucketsDescriptor {
	return batchGetBucketsDescriptor
}

type ListBucketsDescriptor struct{}

type ListBucketsDescriptorClientMsgHandle struct{}

type ListBucketsDescriptorServerMsgHandle struct{}

func (d *ListBucketsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListBucketsRequest{}
}

func (d *ListBucketsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListBucketsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListBucketsDescriptor) GetMethodName() string {
	return "ListBuckets"
}

func (d *ListBucketsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.BucketService/ListBuckets"
}

func (d *ListBucketsDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *ListBucketsDescriptor) GetApiName() string {
	return "BucketService"
}

func (d *ListBucketsDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *ListBucketsDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *ListBucketsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return bucketServiceDescriptor
}

func (d *ListBucketsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return bucket.GetDescriptor()
}

func (d *ListBucketsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListBucketsDescriptorClientMsgHandle{}
}

func (d *ListBucketsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListBucketsDescriptorServerMsgHandle{}
}

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

func (h *ListBucketsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListBucketsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListBucketsRequest) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListBucketsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListBucketsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListBucketsRequest) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListBucketsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListBucketsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListBucketsRequest) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListBucketsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListBucketsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListBucketsResponse) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListBucketsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListBucketsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListBucketsResponse) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetBuckets(); len(resources) > 0 {
			return bucket.BucketList(resources)
		}
	}
	return (bucket.BucketList)(nil)
}

func GetListBucketsDescriptor() *ListBucketsDescriptor {
	return listBucketsDescriptor
}

type WatchBucketDescriptor struct{}

type WatchBucketDescriptorClientMsgHandle struct{}

type WatchBucketDescriptorServerMsgHandle struct{}

func (d *WatchBucketDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchBucketRequest{}
}

func (d *WatchBucketDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchBucketResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchBucketDescriptor) GetMethodName() string {
	return "WatchBucket"
}

func (d *WatchBucketDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.BucketService/WatchBucket"
}

func (d *WatchBucketDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *WatchBucketDescriptor) GetApiName() string {
	return "BucketService"
}

func (d *WatchBucketDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *WatchBucketDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *WatchBucketDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return bucketServiceDescriptor
}

func (d *WatchBucketDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return bucket.GetDescriptor()
}

func (d *WatchBucketDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchBucketDescriptorClientMsgHandle{}
}

func (d *WatchBucketDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchBucketDescriptorServerMsgHandle{}
}

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

func (h *WatchBucketDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchBucketRequest) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchBucketDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchBucketRequest) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchBucketDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchBucketRequest) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchBucketDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchBucketResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchBucketResponse) *bucket.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *bucket.BucketChange_Added_:
				return tResChange.Added.GetBucket().GetName()
			case *bucket.BucketChange_Modified_:
				return tResChange.Modified.GetName()
			case *bucket.BucketChange_Removed_:
				return tResChange.Removed.GetName()
			case *bucket.BucketChange_Current_:
				return tResChange.Current.GetBucket().GetName()
			}
		}
	}
	return (*bucket.Name)(nil)
}

func (h *WatchBucketDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchBucketResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchBucketResponse) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchBucketDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchBucketResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchBucketResponse) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *bucket.BucketChange_Added_:
				return tResChange.Added.GetBucket()
			case *bucket.BucketChange_Modified_:
				return tResChange.Modified.GetBucket()
			case *bucket.BucketChange_Current_:
				return tResChange.Current.GetBucket()
			}
		}
	}
	return (*bucket.Bucket)(nil)
}

func (h *WatchBucketDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchBucketResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchBucketResponse) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchBucketDescriptor() *WatchBucketDescriptor {
	return watchBucketDescriptor
}

type WatchBucketsDescriptor struct{}

type WatchBucketsDescriptorClientMsgHandle struct{}

type WatchBucketsDescriptorServerMsgHandle struct{}

func (d *WatchBucketsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchBucketsRequest{}
}

func (d *WatchBucketsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchBucketsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchBucketsDescriptor) GetMethodName() string {
	return "WatchBuckets"
}

func (d *WatchBucketsDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.BucketService/WatchBuckets"
}

func (d *WatchBucketsDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *WatchBucketsDescriptor) GetApiName() string {
	return "BucketService"
}

func (d *WatchBucketsDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *WatchBucketsDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *WatchBucketsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return bucketServiceDescriptor
}

func (d *WatchBucketsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return bucket.GetDescriptor()
}

func (d *WatchBucketsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchBucketsDescriptorClientMsgHandle{}
}

func (d *WatchBucketsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchBucketsDescriptorServerMsgHandle{}
}

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

func (h *WatchBucketsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchBucketsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchBucketsRequest) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchBucketsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchBucketsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchBucketsRequest) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchBucketsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchBucketsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchBucketsRequest) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchBucketsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchBucketsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchBucketsResponse) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetBucketChanges(); len(resChanges) > 0 {
			list := make(bucket.BucketNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *bucket.BucketChange_Added_:
					list = append(list, tResChange.Added.GetBucket().GetName())
				case *bucket.BucketChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *bucket.BucketChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *bucket.BucketChange_Current_:
					list = append(list, tResChange.Current.GetBucket().GetName())
				}
			}
			return list
		}
	}
	return (bucket.BucketNameList)(nil)
}

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

func (h *WatchBucketsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchBucketsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchBucketsResponse) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchBucketsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchBucketsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchBucketsResponse) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetBucketChanges(); len(resChanges) > 0 {
			list := make(bucket.BucketList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *bucket.BucketChange_Added_:
					list = append(list, tResChange.Added.GetBucket())
				case *bucket.BucketChange_Modified_:
					list = append(list, tResChange.Modified.GetBucket())
				case *bucket.BucketChange_Current_:
					list = append(list, tResChange.Current.GetBucket())
				}
			}
			return list
		}
	}
	return (bucket.BucketList)(nil)
}

func GetWatchBucketsDescriptor() *WatchBucketsDescriptor {
	return watchBucketsDescriptor
}

type CreateBucketDescriptor struct{}

type CreateBucketDescriptorClientMsgHandle struct{}

type CreateBucketDescriptorServerMsgHandle struct{}

func (d *CreateBucketDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateBucketRequest{}
}

func (d *CreateBucketDescriptor) NewEmptyServerMsg() proto.Message {
	return &bucket.Bucket{}
}

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

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

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

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

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

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

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

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

func (d *CreateBucketDescriptor) GetMethodName() string {
	return "CreateBucket"
}

func (d *CreateBucketDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.BucketService/CreateBucket"
}

func (d *CreateBucketDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *CreateBucketDescriptor) GetApiName() string {
	return "BucketService"
}

func (d *CreateBucketDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *CreateBucketDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *CreateBucketDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return bucketServiceDescriptor
}

func (d *CreateBucketDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return bucket.GetDescriptor()
}

func (d *CreateBucketDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateBucketDescriptorClientMsgHandle{}
}

func (d *CreateBucketDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateBucketDescriptorServerMsgHandle{}
}

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

func (h *CreateBucketDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateBucketRequest) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateBucketDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateBucketRequest) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetBucket()
	}
	return (*bucket.Bucket)(nil)
}

func (h *CreateBucketDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateBucketRequest) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateBucketDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*bucket.Bucket)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*bucket.Bucket) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateBucketDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*bucket.Bucket)
}

func (h *CreateBucketDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*bucket.Bucket)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*bucket.Bucket) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateBucketDescriptor() *CreateBucketDescriptor {
	return createBucketDescriptor
}

type UpdateBucketDescriptor struct{}

type UpdateBucketDescriptorClientMsgHandle struct{}

type UpdateBucketDescriptorServerMsgHandle struct{}

func (d *UpdateBucketDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateBucketRequest{}
}

func (d *UpdateBucketDescriptor) NewEmptyServerMsg() proto.Message {
	return &bucket.Bucket{}
}

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

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

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

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

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

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

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

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

func (d *UpdateBucketDescriptor) GetMethodName() string {
	return "UpdateBucket"
}

func (d *UpdateBucketDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.BucketService/UpdateBucket"
}

func (d *UpdateBucketDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *UpdateBucketDescriptor) GetApiName() string {
	return "BucketService"
}

func (d *UpdateBucketDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *UpdateBucketDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *UpdateBucketDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return bucketServiceDescriptor
}

func (d *UpdateBucketDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return bucket.GetDescriptor()
}

func (d *UpdateBucketDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateBucketDescriptorClientMsgHandle{}
}

func (d *UpdateBucketDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateBucketDescriptorServerMsgHandle{}
}

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

func (h *UpdateBucketDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateBucketRequest) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateBucketDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateBucketRequest) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetBucket()
	}
	return (*bucket.Bucket)(nil)
}

func (h *UpdateBucketDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateBucketRequest) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateBucketDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*bucket.Bucket)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*bucket.Bucket) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateBucketDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*bucket.Bucket)
}

func (h *UpdateBucketDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*bucket.Bucket)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*bucket.Bucket) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateBucketDescriptor() *UpdateBucketDescriptor {
	return updateBucketDescriptor
}

type DeleteBucketDescriptor struct{}

type DeleteBucketDescriptorClientMsgHandle struct{}

type DeleteBucketDescriptorServerMsgHandle struct{}

func (d *DeleteBucketDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteBucketRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteBucketDescriptor) GetMethodName() string {
	return "DeleteBucket"
}

func (d *DeleteBucketDescriptor) GetFullMethodName() string {
	return "/ntt.monitoring.v4.BucketService/DeleteBucket"
}

func (d *DeleteBucketDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *DeleteBucketDescriptor) GetApiName() string {
	return "BucketService"
}

func (d *DeleteBucketDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *DeleteBucketDescriptor) GetServiceVersion() string {
	return "v4"
}

func (d *DeleteBucketDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return bucketServiceDescriptor
}

func (d *DeleteBucketDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return bucket.GetDescriptor()
}

func (d *DeleteBucketDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteBucketDescriptorClientMsgHandle{}
}

func (d *DeleteBucketDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteBucketDescriptorServerMsgHandle{}
}

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

func (h *DeleteBucketDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteBucketRequest) []*bucket.Name
	})
	if ok {
		return bucket.BucketNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteBucketDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteBucketRequest) *bucket.Bucket
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteBucketDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteBucketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteBucketRequest) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteBucketDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*bucket.Bucket
	})
	if ok {
		return bucket.BucketList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteBucketDescriptor() *DeleteBucketDescriptor {
	return deleteBucketDescriptor
}

type BucketServiceDescriptor struct{}

func (d *BucketServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getBucketDescriptor,
		batchGetBucketsDescriptor,
		listBucketsDescriptor,
		watchBucketDescriptor,
		watchBucketsDescriptor,
		createBucketDescriptor,
		updateBucketDescriptor,
		deleteBucketDescriptor,
	}
}

func (d *BucketServiceDescriptor) GetFullAPIName() string {
	return "/ntt.monitoring.v4.BucketService"
}

func (d *BucketServiceDescriptor) GetProtoPkgName() string {
	return "ntt.monitoring.v4"
}

func (d *BucketServiceDescriptor) GetApiName() string {
	return "BucketService"
}

func (d *BucketServiceDescriptor) GetServiceDomain() string {
	return "monitoring.edgelq.com"
}

func (d *BucketServiceDescriptor) GetServiceVersion() string {
	return "v4"
}

func GetBucketServiceDescriptor() *BucketServiceDescriptor {
	return bucketServiceDescriptor
}

func initDescriptors() {
	bucketServiceDescriptor = &BucketServiceDescriptor{}
	getBucketDescriptor = &GetBucketDescriptor{}
	batchGetBucketsDescriptor = &BatchGetBucketsDescriptor{}
	listBucketsDescriptor = &ListBucketsDescriptor{}
	watchBucketDescriptor = &WatchBucketDescriptor{}
	watchBucketsDescriptor = &WatchBucketsDescriptor{}
	createBucketDescriptor = &CreateBucketDescriptor{}
	updateBucketDescriptor = &UpdateBucketDescriptor{}
	deleteBucketDescriptor = &DeleteBucketDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(bucketServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getBucketDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetBucketsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listBucketsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchBucketDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchBucketsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createBucketDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateBucketDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteBucketDescriptor)
}

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