distribution_service.pb.descriptors.go

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

package distribution_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 (
	distribution "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha/distribution"
	empty "github.com/golang/protobuf/ptypes/empty"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = new(proto.Message)
	_ = new(gotenclient.MethodDescriptor)
	_ = gotenresource.WildcardId
)

// make sure we're using proto imports
var (
	_ = &distribution.Distribution{}
	_ = &empty.Empty{}
)

var (
	descriptorsInitialized          bool
	distributionServiceDescriptor   *DistributionServiceDescriptor
	getDistributionDescriptor       *GetDistributionDescriptor
	batchGetDistributionsDescriptor *BatchGetDistributionsDescriptor
	listDistributionsDescriptor     *ListDistributionsDescriptor
	watchDistributionDescriptor     *WatchDistributionDescriptor
	watchDistributionsDescriptor    *WatchDistributionsDescriptor
	createDistributionDescriptor    *CreateDistributionDescriptor
	updateDistributionDescriptor    *UpdateDistributionDescriptor
	deleteDistributionDescriptor    *DeleteDistributionDescriptor
)

type GetDistributionDescriptor struct{}

type GetDistributionDescriptorClientMsgHandle struct{}

type GetDistributionDescriptorServerMsgHandle struct{}

func (d *GetDistributionDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetDistributionRequest{}
}

func (d *GetDistributionDescriptor) NewEmptyServerMsg() proto.Message {
	return &distribution.Distribution{}
}

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

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

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

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

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

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

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

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

func (d *GetDistributionDescriptor) GetMethodName() string {
	return "GetDistribution"
}

func (d *GetDistributionDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha.DistributionService/GetDistribution"
}

func (d *GetDistributionDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha"
}

func (d *GetDistributionDescriptor) GetApiName() string {
	return "DistributionService"
}

func (d *GetDistributionDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *GetDistributionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return distributionServiceDescriptor
}

func (d *GetDistributionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return distribution.GetDescriptor()
}

func (d *GetDistributionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetDistributionDescriptorClientMsgHandle{}
}

func (d *GetDistributionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetDistributionDescriptorServerMsgHandle{}
}

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

func (h *GetDistributionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetDistributionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetDistributionRequest) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *GetDistributionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*distribution.Distribution)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*distribution.Distribution) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetGetDistributionDescriptor() *GetDistributionDescriptor {
	return getDistributionDescriptor
}

type BatchGetDistributionsDescriptor struct{}

type BatchGetDistributionsDescriptorClientMsgHandle struct{}

type BatchGetDistributionsDescriptorServerMsgHandle struct{}

func (d *BatchGetDistributionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetDistributionsRequest{}
}

func (d *BatchGetDistributionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetDistributionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetDistributionsDescriptor) GetMethodName() string {
	return "BatchGetDistributions"
}

func (d *BatchGetDistributionsDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha.DistributionService/BatchGetDistributions"
}

func (d *BatchGetDistributionsDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha"
}

func (d *BatchGetDistributionsDescriptor) GetApiName() string {
	return "DistributionService"
}

func (d *BatchGetDistributionsDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *BatchGetDistributionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return distributionServiceDescriptor
}

func (d *BatchGetDistributionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return distribution.GetDescriptor()
}

func (d *BatchGetDistributionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetDistributionsDescriptorClientMsgHandle{}
}

func (d *BatchGetDistributionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetDistributionsDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

func GetBatchGetDistributionsDescriptor() *BatchGetDistributionsDescriptor {
	return batchGetDistributionsDescriptor
}

type ListDistributionsDescriptor struct{}

type ListDistributionsDescriptorClientMsgHandle struct{}

type ListDistributionsDescriptorServerMsgHandle struct{}

func (d *ListDistributionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListDistributionsRequest{}
}

func (d *ListDistributionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListDistributionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListDistributionsDescriptor) GetMethodName() string {
	return "ListDistributions"
}

func (d *ListDistributionsDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha.DistributionService/ListDistributions"
}

func (d *ListDistributionsDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha"
}

func (d *ListDistributionsDescriptor) GetApiName() string {
	return "DistributionService"
}

func (d *ListDistributionsDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *ListDistributionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return distributionServiceDescriptor
}

func (d *ListDistributionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return distribution.GetDescriptor()
}

func (d *ListDistributionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListDistributionsDescriptorClientMsgHandle{}
}

func (d *ListDistributionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListDistributionsDescriptorServerMsgHandle{}
}

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

func (h *ListDistributionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListDistributionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListDistributionsRequest) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

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

func GetListDistributionsDescriptor() *ListDistributionsDescriptor {
	return listDistributionsDescriptor
}

type WatchDistributionDescriptor struct{}

type WatchDistributionDescriptorClientMsgHandle struct{}

type WatchDistributionDescriptorServerMsgHandle struct{}

func (d *WatchDistributionDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchDistributionRequest{}
}

func (d *WatchDistributionDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchDistributionResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchDistributionDescriptor) GetMethodName() string {
	return "WatchDistribution"
}

func (d *WatchDistributionDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha.DistributionService/WatchDistribution"
}

func (d *WatchDistributionDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha"
}

func (d *WatchDistributionDescriptor) GetApiName() string {
	return "DistributionService"
}

func (d *WatchDistributionDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *WatchDistributionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return distributionServiceDescriptor
}

func (d *WatchDistributionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return distribution.GetDescriptor()
}

func (d *WatchDistributionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDistributionDescriptorClientMsgHandle{}
}

func (d *WatchDistributionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDistributionDescriptorServerMsgHandle{}
}

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

func (h *WatchDistributionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchDistributionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchDistributionRequest) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchDistributionDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchDistributionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchDistributionResponse) *distribution.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *distribution.DistributionChange_Added_:
				return tResChange.Added.GetDistribution().GetName()
			case *distribution.DistributionChange_Modified_:
				return tResChange.Modified.GetName()
			case *distribution.DistributionChange_Removed_:
				return tResChange.Removed.GetName()
			case *distribution.DistributionChange_Current_:
				return tResChange.Current.GetDistribution().GetName()
			}
		}
	}
	return (*distribution.Name)(nil)
}

func (h *WatchDistributionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchDistributionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchDistributionResponse) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetWatchDistributionDescriptor() *WatchDistributionDescriptor {
	return watchDistributionDescriptor
}

type WatchDistributionsDescriptor struct{}

type WatchDistributionsDescriptorClientMsgHandle struct{}

type WatchDistributionsDescriptorServerMsgHandle struct{}

func (d *WatchDistributionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchDistributionsRequest{}
}

func (d *WatchDistributionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchDistributionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchDistributionsDescriptor) GetMethodName() string {
	return "WatchDistributions"
}

func (d *WatchDistributionsDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha.DistributionService/WatchDistributions"
}

func (d *WatchDistributionsDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha"
}

func (d *WatchDistributionsDescriptor) GetApiName() string {
	return "DistributionService"
}

func (d *WatchDistributionsDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *WatchDistributionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return distributionServiceDescriptor
}

func (d *WatchDistributionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return distribution.GetDescriptor()
}

func (d *WatchDistributionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDistributionsDescriptorClientMsgHandle{}
}

func (d *WatchDistributionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDistributionsDescriptorServerMsgHandle{}
}

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

func (h *WatchDistributionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchDistributionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchDistributionsRequest) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *WatchDistributionsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchDistributionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchDistributionsResponse) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetDistributionChanges(); len(resChanges) > 0 {
			list := make(distribution.DistributionNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *distribution.DistributionChange_Added_:
					list = append(list, tResChange.Added.GetDistribution().GetName())
				case *distribution.DistributionChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *distribution.DistributionChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *distribution.DistributionChange_Current_:
					list = append(list, tResChange.Current.GetDistribution().GetName())
				}
			}
			return list
		}
	}
	return (distribution.DistributionNameList)(nil)
}

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

func GetWatchDistributionsDescriptor() *WatchDistributionsDescriptor {
	return watchDistributionsDescriptor
}

type CreateDistributionDescriptor struct{}

type CreateDistributionDescriptorClientMsgHandle struct{}

type CreateDistributionDescriptorServerMsgHandle struct{}

func (d *CreateDistributionDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateDistributionRequest{}
}

func (d *CreateDistributionDescriptor) NewEmptyServerMsg() proto.Message {
	return &distribution.Distribution{}
}

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

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

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

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

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

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

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

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

func (d *CreateDistributionDescriptor) GetMethodName() string {
	return "CreateDistribution"
}

func (d *CreateDistributionDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha.DistributionService/CreateDistribution"
}

func (d *CreateDistributionDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha"
}

func (d *CreateDistributionDescriptor) GetApiName() string {
	return "DistributionService"
}

func (d *CreateDistributionDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *CreateDistributionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return distributionServiceDescriptor
}

func (d *CreateDistributionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return distribution.GetDescriptor()
}

func (d *CreateDistributionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateDistributionDescriptorClientMsgHandle{}
}

func (d *CreateDistributionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateDistributionDescriptorServerMsgHandle{}
}

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

func (h *CreateDistributionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateDistributionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateDistributionRequest) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *CreateDistributionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*distribution.Distribution)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*distribution.Distribution) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetCreateDistributionDescriptor() *CreateDistributionDescriptor {
	return createDistributionDescriptor
}

type UpdateDistributionDescriptor struct{}

type UpdateDistributionDescriptorClientMsgHandle struct{}

type UpdateDistributionDescriptorServerMsgHandle struct{}

func (d *UpdateDistributionDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateDistributionRequest{}
}

func (d *UpdateDistributionDescriptor) NewEmptyServerMsg() proto.Message {
	return &distribution.Distribution{}
}

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

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

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

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

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

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

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

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

func (d *UpdateDistributionDescriptor) GetMethodName() string {
	return "UpdateDistribution"
}

func (d *UpdateDistributionDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha.DistributionService/UpdateDistribution"
}

func (d *UpdateDistributionDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha"
}

func (d *UpdateDistributionDescriptor) GetApiName() string {
	return "DistributionService"
}

func (d *UpdateDistributionDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *UpdateDistributionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return distributionServiceDescriptor
}

func (d *UpdateDistributionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return distribution.GetDescriptor()
}

func (d *UpdateDistributionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateDistributionDescriptorClientMsgHandle{}
}

func (d *UpdateDistributionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateDistributionDescriptorServerMsgHandle{}
}

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

func (h *UpdateDistributionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateDistributionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateDistributionRequest) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

func (h *UpdateDistributionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*distribution.Distribution)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*distribution.Distribution) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func GetUpdateDistributionDescriptor() *UpdateDistributionDescriptor {
	return updateDistributionDescriptor
}

type DeleteDistributionDescriptor struct{}

type DeleteDistributionDescriptorClientMsgHandle struct{}

type DeleteDistributionDescriptorServerMsgHandle struct{}

func (d *DeleteDistributionDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteDistributionRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteDistributionDescriptor) GetMethodName() string {
	return "DeleteDistribution"
}

func (d *DeleteDistributionDescriptor) GetFullMethodName() string {
	return "/ntt.applications.v1alpha.DistributionService/DeleteDistribution"
}

func (d *DeleteDistributionDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha"
}

func (d *DeleteDistributionDescriptor) GetApiName() string {
	return "DistributionService"
}

func (d *DeleteDistributionDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func (d *DeleteDistributionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return distributionServiceDescriptor
}

func (d *DeleteDistributionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return distribution.GetDescriptor()
}

func (d *DeleteDistributionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteDistributionDescriptorClientMsgHandle{}
}

func (d *DeleteDistributionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteDistributionDescriptorServerMsgHandle{}
}

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

func (h *DeleteDistributionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteDistributionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteDistributionRequest) []*distribution.Name
	})
	if ok {
		return distribution.DistributionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

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

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

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

func GetDeleteDistributionDescriptor() *DeleteDistributionDescriptor {
	return deleteDistributionDescriptor
}

type DistributionServiceDescriptor struct{}

func (d *DistributionServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getDistributionDescriptor,
		batchGetDistributionsDescriptor,
		listDistributionsDescriptor,
		watchDistributionDescriptor,
		watchDistributionsDescriptor,
		createDistributionDescriptor,
		updateDistributionDescriptor,
		deleteDistributionDescriptor,
	}
}

func (d *DistributionServiceDescriptor) GetFullAPIName() string {
	return "/ntt.applications.v1alpha.DistributionService"
}

func (d *DistributionServiceDescriptor) GetProtoPkgName() string {
	return "ntt.applications.v1alpha"
}

func (d *DistributionServiceDescriptor) GetApiName() string {
	return "DistributionService"
}

func (d *DistributionServiceDescriptor) GetServiceDomain() string {
	return "applications.edgelq.com"
}

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

func GetDistributionServiceDescriptor() *DistributionServiceDescriptor {
	return distributionServiceDescriptor
}

func initDescriptors() {
	distributionServiceDescriptor = &DistributionServiceDescriptor{}
	getDistributionDescriptor = &GetDistributionDescriptor{}
	batchGetDistributionsDescriptor = &BatchGetDistributionsDescriptor{}
	listDistributionsDescriptor = &ListDistributionsDescriptor{}
	watchDistributionDescriptor = &WatchDistributionDescriptor{}
	watchDistributionsDescriptor = &WatchDistributionsDescriptor{}
	createDistributionDescriptor = &CreateDistributionDescriptor{}
	updateDistributionDescriptor = &UpdateDistributionDescriptor{}
	deleteDistributionDescriptor = &DeleteDistributionDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(distributionServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getDistributionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetDistributionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listDistributionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchDistributionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchDistributionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createDistributionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateDistributionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteDistributionDescriptor)
}

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