github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/client/v1/ts_condition/ts_condition_service.pb.descriptors.go

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

package ts_condition_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 (
	ts_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/ts_condition"
	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 (
	_ = &ts_condition.TsCondition{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized         bool
	tsConditionServiceDescriptor   *TsConditionServiceDescriptor
	getTsConditionDescriptor       *GetTsConditionDescriptor
	batchGetTsConditionsDescriptor *BatchGetTsConditionsDescriptor
	listTsConditionsDescriptor     *ListTsConditionsDescriptor
	watchTsConditionDescriptor     *WatchTsConditionDescriptor
	watchTsConditionsDescriptor    *WatchTsConditionsDescriptor
	createTsConditionDescriptor    *CreateTsConditionDescriptor
	updateTsConditionDescriptor    *UpdateTsConditionDescriptor
	deleteTsConditionDescriptor    *DeleteTsConditionDescriptor
	searchTsConditionsDescriptor   *SearchTsConditionsDescriptor
)

type GetTsConditionDescriptor struct{}

type GetTsConditionDescriptorClientMsgHandle struct{}

type GetTsConditionDescriptorServerMsgHandle struct{}

func (d *GetTsConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetTsConditionRequest{}
}

func (d *GetTsConditionDescriptor) NewEmptyServerMsg() proto.Message {
	return &ts_condition.TsCondition{}
}

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

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

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

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

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

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

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

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

func (d *GetTsConditionDescriptor) GetMethodName() string {
	return "GetTsCondition"
}

func (d *GetTsConditionDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.TsConditionService/GetTsCondition"
}

func (d *GetTsConditionDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *GetTsConditionDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *GetTsConditionDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func (d *GetTsConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return tsConditionServiceDescriptor
}

func (d *GetTsConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return ts_condition.GetDescriptor()
}

func (d *GetTsConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetTsConditionDescriptorClientMsgHandle{}
}

func (d *GetTsConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetTsConditionDescriptorServerMsgHandle{}
}

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

func (h *GetTsConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetTsConditionRequest) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetTsConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetTsConditionRequest) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetTsConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetTsConditionRequest) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetTsConditionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ts_condition.TsCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ts_condition.TsCondition) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetTsConditionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*ts_condition.TsCondition)
}

func (h *GetTsConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ts_condition.TsCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ts_condition.TsCondition) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetTsConditionDescriptor() *GetTsConditionDescriptor {
	return getTsConditionDescriptor
}

type BatchGetTsConditionsDescriptor struct{}

type BatchGetTsConditionsDescriptorClientMsgHandle struct{}

type BatchGetTsConditionsDescriptorServerMsgHandle struct{}

func (d *BatchGetTsConditionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetTsConditionsRequest{}
}

func (d *BatchGetTsConditionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetTsConditionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetTsConditionsDescriptor) GetMethodName() string {
	return "BatchGetTsConditions"
}

func (d *BatchGetTsConditionsDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.TsConditionService/BatchGetTsConditions"
}

func (d *BatchGetTsConditionsDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *BatchGetTsConditionsDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *BatchGetTsConditionsDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func (d *BatchGetTsConditionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return tsConditionServiceDescriptor
}

func (d *BatchGetTsConditionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return ts_condition.GetDescriptor()
}

func (d *BatchGetTsConditionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetTsConditionsDescriptorClientMsgHandle{}
}

func (d *BatchGetTsConditionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetTsConditionsDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetTsConditionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetTsConditionsRequest) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetTsConditionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetTsConditionsRequest) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetTsConditionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetTsConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetTsConditionsResponse) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetTsConditionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetTsConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetTsConditionsResponse) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetTsConditions(); len(resources) > 0 {
			return ts_condition.TsConditionList(resources)
		}
	}
	return (ts_condition.TsConditionList)(nil)
}

func GetBatchGetTsConditionsDescriptor() *BatchGetTsConditionsDescriptor {
	return batchGetTsConditionsDescriptor
}

type ListTsConditionsDescriptor struct{}

type ListTsConditionsDescriptorClientMsgHandle struct{}

type ListTsConditionsDescriptorServerMsgHandle struct{}

func (d *ListTsConditionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListTsConditionsRequest{}
}

func (d *ListTsConditionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListTsConditionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListTsConditionsDescriptor) GetMethodName() string {
	return "ListTsConditions"
}

func (d *ListTsConditionsDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.TsConditionService/ListTsConditions"
}

func (d *ListTsConditionsDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *ListTsConditionsDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *ListTsConditionsDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func (d *ListTsConditionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return tsConditionServiceDescriptor
}

func (d *ListTsConditionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return ts_condition.GetDescriptor()
}

func (d *ListTsConditionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListTsConditionsDescriptorClientMsgHandle{}
}

func (d *ListTsConditionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListTsConditionsDescriptorServerMsgHandle{}
}

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

func (h *ListTsConditionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListTsConditionsRequest) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListTsConditionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListTsConditionsRequest) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListTsConditionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListTsConditionsRequest) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListTsConditionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListTsConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListTsConditionsResponse) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListTsConditionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListTsConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListTsConditionsResponse) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetTsConditions(); len(resources) > 0 {
			return ts_condition.TsConditionList(resources)
		}
	}
	return (ts_condition.TsConditionList)(nil)
}

func GetListTsConditionsDescriptor() *ListTsConditionsDescriptor {
	return listTsConditionsDescriptor
}

type WatchTsConditionDescriptor struct{}

type WatchTsConditionDescriptorClientMsgHandle struct{}

type WatchTsConditionDescriptorServerMsgHandle struct{}

func (d *WatchTsConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchTsConditionRequest{}
}

func (d *WatchTsConditionDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchTsConditionResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchTsConditionDescriptor) GetMethodName() string {
	return "WatchTsCondition"
}

func (d *WatchTsConditionDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.TsConditionService/WatchTsCondition"
}

func (d *WatchTsConditionDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *WatchTsConditionDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *WatchTsConditionDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func (d *WatchTsConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return tsConditionServiceDescriptor
}

func (d *WatchTsConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return ts_condition.GetDescriptor()
}

func (d *WatchTsConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchTsConditionDescriptorClientMsgHandle{}
}

func (d *WatchTsConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchTsConditionDescriptorServerMsgHandle{}
}

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

func (h *WatchTsConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchTsConditionRequest) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchTsConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchTsConditionRequest) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchTsConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchTsConditionRequest) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchTsConditionDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchTsConditionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchTsConditionResponse) *ts_condition.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *ts_condition.TsConditionChange_Added_:
				return tResChange.Added.GetTsCondition().GetName()
			case *ts_condition.TsConditionChange_Modified_:
				return tResChange.Modified.GetName()
			case *ts_condition.TsConditionChange_Removed_:
				return tResChange.Removed.GetName()
			case *ts_condition.TsConditionChange_Current_:
				return tResChange.Current.GetTsCondition().GetName()
			}
		}
	}
	return (*ts_condition.Name)(nil)
}

func (h *WatchTsConditionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchTsConditionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchTsConditionResponse) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchTsConditionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchTsConditionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchTsConditionResponse) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *ts_condition.TsConditionChange_Added_:
				return tResChange.Added.GetTsCondition()
			case *ts_condition.TsConditionChange_Modified_:
				return tResChange.Modified.GetTsCondition()
			case *ts_condition.TsConditionChange_Current_:
				return tResChange.Current.GetTsCondition()
			}
		}
	}
	return (*ts_condition.TsCondition)(nil)
}

func (h *WatchTsConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchTsConditionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchTsConditionResponse) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchTsConditionDescriptor() *WatchTsConditionDescriptor {
	return watchTsConditionDescriptor
}

type WatchTsConditionsDescriptor struct{}

type WatchTsConditionsDescriptorClientMsgHandle struct{}

type WatchTsConditionsDescriptorServerMsgHandle struct{}

func (d *WatchTsConditionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchTsConditionsRequest{}
}

func (d *WatchTsConditionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchTsConditionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchTsConditionsDescriptor) GetMethodName() string {
	return "WatchTsConditions"
}

func (d *WatchTsConditionsDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.TsConditionService/WatchTsConditions"
}

func (d *WatchTsConditionsDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *WatchTsConditionsDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *WatchTsConditionsDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func (d *WatchTsConditionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return tsConditionServiceDescriptor
}

func (d *WatchTsConditionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return ts_condition.GetDescriptor()
}

func (d *WatchTsConditionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchTsConditionsDescriptorClientMsgHandle{}
}

func (d *WatchTsConditionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchTsConditionsDescriptorServerMsgHandle{}
}

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

func (h *WatchTsConditionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchTsConditionsRequest) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchTsConditionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchTsConditionsRequest) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchTsConditionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchTsConditionsRequest) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchTsConditionsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchTsConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchTsConditionsResponse) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetTsConditionChanges(); len(resChanges) > 0 {
			list := make(ts_condition.TsConditionNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *ts_condition.TsConditionChange_Added_:
					list = append(list, tResChange.Added.GetTsCondition().GetName())
				case *ts_condition.TsConditionChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *ts_condition.TsConditionChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *ts_condition.TsConditionChange_Current_:
					list = append(list, tResChange.Current.GetTsCondition().GetName())
				}
			}
			return list
		}
	}
	return (ts_condition.TsConditionNameList)(nil)
}

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

func (h *WatchTsConditionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchTsConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchTsConditionsResponse) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchTsConditionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchTsConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchTsConditionsResponse) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetTsConditionChanges(); len(resChanges) > 0 {
			list := make(ts_condition.TsConditionList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *ts_condition.TsConditionChange_Added_:
					list = append(list, tResChange.Added.GetTsCondition())
				case *ts_condition.TsConditionChange_Modified_:
					list = append(list, tResChange.Modified.GetTsCondition())
				case *ts_condition.TsConditionChange_Current_:
					list = append(list, tResChange.Current.GetTsCondition())
				}
			}
			return list
		}
	}
	return (ts_condition.TsConditionList)(nil)
}

func GetWatchTsConditionsDescriptor() *WatchTsConditionsDescriptor {
	return watchTsConditionsDescriptor
}

type CreateTsConditionDescriptor struct{}

type CreateTsConditionDescriptorClientMsgHandle struct{}

type CreateTsConditionDescriptorServerMsgHandle struct{}

func (d *CreateTsConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateTsConditionRequest{}
}

func (d *CreateTsConditionDescriptor) NewEmptyServerMsg() proto.Message {
	return &ts_condition.TsCondition{}
}

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

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

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

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

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

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

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

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

func (d *CreateTsConditionDescriptor) GetMethodName() string {
	return "CreateTsCondition"
}

func (d *CreateTsConditionDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.TsConditionService/CreateTsCondition"
}

func (d *CreateTsConditionDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *CreateTsConditionDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *CreateTsConditionDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func (d *CreateTsConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return tsConditionServiceDescriptor
}

func (d *CreateTsConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return ts_condition.GetDescriptor()
}

func (d *CreateTsConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateTsConditionDescriptorClientMsgHandle{}
}

func (d *CreateTsConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateTsConditionDescriptorServerMsgHandle{}
}

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

func (h *CreateTsConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateTsConditionRequest) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateTsConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateTsConditionRequest) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetTsCondition()
	}
	return (*ts_condition.TsCondition)(nil)
}

func (h *CreateTsConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateTsConditionRequest) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateTsConditionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ts_condition.TsCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ts_condition.TsCondition) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateTsConditionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*ts_condition.TsCondition)
}

func (h *CreateTsConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ts_condition.TsCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ts_condition.TsCondition) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateTsConditionDescriptor() *CreateTsConditionDescriptor {
	return createTsConditionDescriptor
}

type UpdateTsConditionDescriptor struct{}

type UpdateTsConditionDescriptorClientMsgHandle struct{}

type UpdateTsConditionDescriptorServerMsgHandle struct{}

func (d *UpdateTsConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateTsConditionRequest{}
}

func (d *UpdateTsConditionDescriptor) NewEmptyServerMsg() proto.Message {
	return &ts_condition.TsCondition{}
}

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

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

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

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

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

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

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

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

func (d *UpdateTsConditionDescriptor) GetMethodName() string {
	return "UpdateTsCondition"
}

func (d *UpdateTsConditionDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.TsConditionService/UpdateTsCondition"
}

func (d *UpdateTsConditionDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *UpdateTsConditionDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *UpdateTsConditionDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func (d *UpdateTsConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return tsConditionServiceDescriptor
}

func (d *UpdateTsConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return ts_condition.GetDescriptor()
}

func (d *UpdateTsConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateTsConditionDescriptorClientMsgHandle{}
}

func (d *UpdateTsConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateTsConditionDescriptorServerMsgHandle{}
}

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

func (h *UpdateTsConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateTsConditionRequest) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateTsConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateTsConditionRequest) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetTsCondition()
	}
	return (*ts_condition.TsCondition)(nil)
}

func (h *UpdateTsConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateTsConditionRequest) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateTsConditionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ts_condition.TsCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ts_condition.TsCondition) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateTsConditionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*ts_condition.TsCondition)
}

func (h *UpdateTsConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ts_condition.TsCondition)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ts_condition.TsCondition) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateTsConditionDescriptor() *UpdateTsConditionDescriptor {
	return updateTsConditionDescriptor
}

type DeleteTsConditionDescriptor struct{}

type DeleteTsConditionDescriptorClientMsgHandle struct{}

type DeleteTsConditionDescriptorServerMsgHandle struct{}

func (d *DeleteTsConditionDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteTsConditionRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteTsConditionDescriptor) GetMethodName() string {
	return "DeleteTsCondition"
}

func (d *DeleteTsConditionDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.TsConditionService/DeleteTsCondition"
}

func (d *DeleteTsConditionDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *DeleteTsConditionDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *DeleteTsConditionDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func (d *DeleteTsConditionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return tsConditionServiceDescriptor
}

func (d *DeleteTsConditionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return ts_condition.GetDescriptor()
}

func (d *DeleteTsConditionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteTsConditionDescriptorClientMsgHandle{}
}

func (d *DeleteTsConditionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteTsConditionDescriptorServerMsgHandle{}
}

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

func (h *DeleteTsConditionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteTsConditionRequest) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteTsConditionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteTsConditionRequest) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteTsConditionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteTsConditionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteTsConditionRequest) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteTsConditionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteTsConditionDescriptor() *DeleteTsConditionDescriptor {
	return deleteTsConditionDescriptor
}

type SearchTsConditionsDescriptor struct{}

type SearchTsConditionsDescriptorClientMsgHandle struct{}

type SearchTsConditionsDescriptorServerMsgHandle struct{}

func (d *SearchTsConditionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &SearchTsConditionsRequest{}
}

func (d *SearchTsConditionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &SearchTsConditionsResponse{}
}

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

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

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

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

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

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

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

func (d *SearchTsConditionsDescriptor) GetVerb() string {
	return "search"
}

func (d *SearchTsConditionsDescriptor) GetMethodName() string {
	return "SearchTsConditions"
}

func (d *SearchTsConditionsDescriptor) GetFullMethodName() string {
	return "/ntt.alerting.v1.TsConditionService/SearchTsConditions"
}

func (d *SearchTsConditionsDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *SearchTsConditionsDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *SearchTsConditionsDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func (d *SearchTsConditionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return tsConditionServiceDescriptor
}

func (d *SearchTsConditionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return ts_condition.GetDescriptor()
}

func (d *SearchTsConditionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchTsConditionsDescriptorClientMsgHandle{}
}

func (d *SearchTsConditionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &SearchTsConditionsDescriptorServerMsgHandle{}
}

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

func (h *SearchTsConditionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*SearchTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*SearchTsConditionsRequest) []*ts_condition.Name
	})
	if ok {
		return ts_condition.TsConditionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *SearchTsConditionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SearchTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SearchTsConditionsRequest) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SearchTsConditionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SearchTsConditionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SearchTsConditionsRequest) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *SearchTsConditionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*SearchTsConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*SearchTsConditionsResponse) *ts_condition.TsCondition
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *SearchTsConditionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*SearchTsConditionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*SearchTsConditionsResponse) []*ts_condition.TsCondition
	})
	if ok {
		return ts_condition.TsConditionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetTsConditions(); len(resources) > 0 {
			return ts_condition.TsConditionList(resources)
		}
	}
	return (ts_condition.TsConditionList)(nil)
}

func GetSearchTsConditionsDescriptor() *SearchTsConditionsDescriptor {
	return searchTsConditionsDescriptor
}

type TsConditionServiceDescriptor struct{}

func (d *TsConditionServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getTsConditionDescriptor,
		batchGetTsConditionsDescriptor,
		listTsConditionsDescriptor,
		watchTsConditionDescriptor,
		watchTsConditionsDescriptor,
		createTsConditionDescriptor,
		updateTsConditionDescriptor,
		deleteTsConditionDescriptor,
		searchTsConditionsDescriptor,
	}
}

func (d *TsConditionServiceDescriptor) GetFullAPIName() string {
	return "/ntt.alerting.v1.TsConditionService"
}

func (d *TsConditionServiceDescriptor) GetProtoPkgName() string {
	return "ntt.alerting.v1"
}

func (d *TsConditionServiceDescriptor) GetApiName() string {
	return "TsConditionService"
}

func (d *TsConditionServiceDescriptor) GetServiceDomain() string {
	return "alerting.edgelq.com"
}

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

func GetTsConditionServiceDescriptor() *TsConditionServiceDescriptor {
	return tsConditionServiceDescriptor
}

func initDescriptors() {
	tsConditionServiceDescriptor = &TsConditionServiceDescriptor{}
	getTsConditionDescriptor = &GetTsConditionDescriptor{}
	batchGetTsConditionsDescriptor = &BatchGetTsConditionsDescriptor{}
	listTsConditionsDescriptor = &ListTsConditionsDescriptor{}
	watchTsConditionDescriptor = &WatchTsConditionDescriptor{}
	watchTsConditionsDescriptor = &WatchTsConditionsDescriptor{}
	createTsConditionDescriptor = &CreateTsConditionDescriptor{}
	updateTsConditionDescriptor = &UpdateTsConditionDescriptor{}
	deleteTsConditionDescriptor = &DeleteTsConditionDescriptor{}
	searchTsConditionsDescriptor = &SearchTsConditionsDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(tsConditionServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getTsConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetTsConditionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listTsConditionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchTsConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchTsConditionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createTsConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateTsConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteTsConditionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(searchTsConditionsDescriptor)
}

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