tasks/api/taskqueue/v1/message.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// plugins:
// 	protoc-gen-go
// 	protoc
// source: temporal/server/api/taskqueue/v1/message.proto

package taskqueue

import (
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"

	v11 "go.temporal.io/api/deployment/v1"
	v1 "go.temporal.io/api/enums/v1"
	v13 "go.temporal.io/api/taskqueue/v1"
	v12 "go.temporal.io/server/api/deployment/v1"
	v14 "go.temporal.io/server/api/enums/v1"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// TaskVersionDirective controls how matching should direct a task.
type TaskVersionDirective struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Default (if build_id is not present) is "unversioned":
	// Use the unversioned task queue, even if the task queue has versioning data.
	// Absent value means the task is the non-starting task of an unversioned execution so it should remain unversioned.
	// Deprecated. Use deployment_version.
	//
	// Types that are valid to be assigned to BuildId:
	//
	//	*TaskVersionDirective_UseAssignmentRules
	//	*TaskVersionDirective_AssignedBuildId
	BuildId isTaskVersionDirective_BuildId `protobuf_oneof:"build_id"`
	// Workflow's effective behavior when the task is scheduled.
	Behavior v1.VersioningBehavior `protobuf:"varint,3,opt,name=behavior,proto3,enum=temporal.api.enums.v1.VersioningBehavior" json:"behavior,omitempty"`
	// Workflow's effective deployment when the task is scheduled.
	// Deprecated. Use deployment_version.
	Deployment *v11.Deployment `protobuf:"bytes,4,opt,name=deployment,proto3" json:"deployment,omitempty"`
	// Workflow's effective deployment version when the task is scheduled.
	DeploymentVersion *v12.WorkerDeploymentVersion `protobuf:"bytes,5,opt,name=deployment_version,json=deploymentVersion,proto3" json:"deployment_version,omitempty"`
	// Counter copied from the workflow execution's WorkflowExecutionVersioningInfo
	// during enqueue time.
	RevisionNumber int64 `protobuf:"varint,6,opt,name=revision_number,json=revisionNumber,proto3" json:"revision_number,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *TaskVersionDirective) Reset() {
	*x = TaskVersionDirective{}
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TaskVersionDirective) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TaskVersionDirective) ProtoMessage() {}

func (x *TaskVersionDirective) ProtoReflect() protoreflect.Message {
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TaskVersionDirective.ProtoReflect.Descriptor instead.
func (*TaskVersionDirective) Descriptor() ([]byte, []int) {
	return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{0}
}

func (x *TaskVersionDirective) GetBuildId() isTaskVersionDirective_BuildId {
	if x != nil {
		return x.BuildId
	}
	return nil
}

func (x *TaskVersionDirective) GetUseAssignmentRules() *emptypb.Empty {
	if x != nil {
		if x, ok := x.BuildId.(*TaskVersionDirective_UseAssignmentRules); ok {
			return x.UseAssignmentRules
		}
	}
	return nil
}

func (x *TaskVersionDirective) GetAssignedBuildId() string {
	if x != nil {
		if x, ok := x.BuildId.(*TaskVersionDirective_AssignedBuildId); ok {
			return x.AssignedBuildId
		}
	}
	return ""
}

func (x *TaskVersionDirective) GetBehavior() v1.VersioningBehavior {
	if x != nil {
		return x.Behavior
	}
	return v1.VersioningBehavior(0)
}

func (x *TaskVersionDirective) GetDeployment() *v11.Deployment {
	if x != nil {
		return x.Deployment
	}
	return nil
}

func (x *TaskVersionDirective) GetDeploymentVersion() *v12.WorkerDeploymentVersion {
	if x != nil {
		return x.DeploymentVersion
	}
	return nil
}

func (x *TaskVersionDirective) GetRevisionNumber() int64 {
	if x != nil {
		return x.RevisionNumber
	}
	return 0
}

type isTaskVersionDirective_BuildId interface {
	isTaskVersionDirective_BuildId()
}

type TaskVersionDirective_UseAssignmentRules struct {
	// If use_assignment_rules is present, matching should use the assignment rules
	// to determine the build ID.
	// WV1: the task should be assigned the default version for the task queue. [cleanup-old-wv]
	UseAssignmentRules *emptypb.Empty `protobuf:"bytes,1,opt,name=use_assignment_rules,json=useAssignmentRules,proto3,oneof"`
}

type TaskVersionDirective_AssignedBuildId struct {
	// This means the task is already assigned to `build_id`
	// WV1: If assigned_build_id is present, use the default version in the compatible set
	// containing this build ID. [cleanup-old-wv]
	AssignedBuildId string `protobuf:"bytes,2,opt,name=assigned_build_id,json=assignedBuildId,proto3,oneof"`
}

func (*TaskVersionDirective_UseAssignmentRules) isTaskVersionDirective_BuildId() {}

func (*TaskVersionDirective_AssignedBuildId) isTaskVersionDirective_BuildId() {}

type FairLevel struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TaskPass      int64                  `protobuf:"varint,1,opt,name=task_pass,json=taskPass,proto3" json:"task_pass,omitempty"`
	TaskId        int64                  `protobuf:"varint,2,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FairLevel) Reset() {
	*x = FairLevel{}
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FairLevel) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FairLevel) ProtoMessage() {}

func (x *FairLevel) ProtoReflect() protoreflect.Message {
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FairLevel.ProtoReflect.Descriptor instead.
func (*FairLevel) Descriptor() ([]byte, []int) {
	return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{1}
}

func (x *FairLevel) GetTaskPass() int64 {
	if x != nil {
		return x.TaskPass
	}
	return 0
}

func (x *FairLevel) GetTaskId() int64 {
	if x != nil {
		return x.TaskId
	}
	return 0
}

type InternalTaskQueueStatus struct {
	state                   protoimpl.MessageState `protogen:"open.v1"`
	ReadLevel               int64                  `protobuf:"varint,1,opt,name=read_level,json=readLevel,proto3" json:"read_level,omitempty"`
	FairReadLevel           *FairLevel             `protobuf:"bytes,7,opt,name=fair_read_level,json=fairReadLevel,proto3" json:"fair_read_level,omitempty"`
	AckLevel                int64                  `protobuf:"varint,2,opt,name=ack_level,json=ackLevel,proto3" json:"ack_level,omitempty"`
	FairAckLevel            *FairLevel             `protobuf:"bytes,8,opt,name=fair_ack_level,json=fairAckLevel,proto3" json:"fair_ack_level,omitempty"`
	TaskIdBlock             *v13.TaskIdBlock       `protobuf:"bytes,3,opt,name=task_id_block,json=taskIdBlock,proto3" json:"task_id_block,omitempty"`
	LoadedTasks             int64                  `protobuf:"varint,4,opt,name=loaded_tasks,json=loadedTasks,proto3" json:"loaded_tasks,omitempty"`
	ApproximateBacklogCount int64                  `protobuf:"varint,5,opt,name=approximate_backlog_count,json=approximateBacklogCount,proto3" json:"approximate_backlog_count,omitempty"`
	MaxReadLevel            int64                  `protobuf:"varint,6,opt,name=max_read_level,json=maxReadLevel,proto3" json:"max_read_level,omitempty"`
	FairMaxReadLevel        *FairLevel             `protobuf:"bytes,9,opt,name=fair_max_read_level,json=fairMaxReadLevel,proto3" json:"fair_max_read_level,omitempty"`
	// Draining means that this status is from a draining queue.
	Draining      bool `protobuf:"varint,10,opt,name=draining,proto3" json:"draining,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *InternalTaskQueueStatus) Reset() {
	*x = InternalTaskQueueStatus{}
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *InternalTaskQueueStatus) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*InternalTaskQueueStatus) ProtoMessage() {}

func (x *InternalTaskQueueStatus) ProtoReflect() protoreflect.Message {
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use InternalTaskQueueStatus.ProtoReflect.Descriptor instead.
func (*InternalTaskQueueStatus) Descriptor() ([]byte, []int) {
	return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{2}
}

func (x *InternalTaskQueueStatus) GetReadLevel() int64 {
	if x != nil {
		return x.ReadLevel
	}
	return 0
}

func (x *InternalTaskQueueStatus) GetFairReadLevel() *FairLevel {
	if x != nil {
		return x.FairReadLevel
	}
	return nil
}

func (x *InternalTaskQueueStatus) GetAckLevel() int64 {
	if x != nil {
		return x.AckLevel
	}
	return 0
}

func (x *InternalTaskQueueStatus) GetFairAckLevel() *FairLevel {
	if x != nil {
		return x.FairAckLevel
	}
	return nil
}

func (x *InternalTaskQueueStatus) GetTaskIdBlock() *v13.TaskIdBlock {
	if x != nil {
		return x.TaskIdBlock
	}
	return nil
}

func (x *InternalTaskQueueStatus) GetLoadedTasks() int64 {
	if x != nil {
		return x.LoadedTasks
	}
	return 0
}

func (x *InternalTaskQueueStatus) GetApproximateBacklogCount() int64 {
	if x != nil {
		return x.ApproximateBacklogCount
	}
	return 0
}

func (x *InternalTaskQueueStatus) GetMaxReadLevel() int64 {
	if x != nil {
		return x.MaxReadLevel
	}
	return 0
}

func (x *InternalTaskQueueStatus) GetFairMaxReadLevel() *FairLevel {
	if x != nil {
		return x.FairMaxReadLevel
	}
	return nil
}

func (x *InternalTaskQueueStatus) GetDraining() bool {
	if x != nil {
		return x.Draining
	}
	return false
}

type TaskQueueVersionInfoInternal struct {
	state                 protoimpl.MessageState `protogen:"open.v1"`
	PhysicalTaskQueueInfo *PhysicalTaskQueueInfo `protobuf:"bytes,2,opt,name=physical_task_queue_info,json=physicalTaskQueueInfo,proto3" json:"physical_task_queue_info,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *TaskQueueVersionInfoInternal) Reset() {
	*x = TaskQueueVersionInfoInternal{}
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TaskQueueVersionInfoInternal) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TaskQueueVersionInfoInternal) ProtoMessage() {}

func (x *TaskQueueVersionInfoInternal) ProtoReflect() protoreflect.Message {
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TaskQueueVersionInfoInternal.ProtoReflect.Descriptor instead.
func (*TaskQueueVersionInfoInternal) Descriptor() ([]byte, []int) {
	return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{3}
}

func (x *TaskQueueVersionInfoInternal) GetPhysicalTaskQueueInfo() *PhysicalTaskQueueInfo {
	if x != nil {
		return x.PhysicalTaskQueueInfo
	}
	return nil
}

type PhysicalTaskQueueInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Unversioned workers (with `useVersioning=false`) are reported in unversioned result even if they set a Build ID.
	Pollers                 []*v13.PollerInfo          `protobuf:"bytes,1,rep,name=pollers,proto3" json:"pollers,omitempty"`
	InternalTaskQueueStatus []*InternalTaskQueueStatus `protobuf:"bytes,3,rep,name=internal_task_queue_status,json=internalTaskQueueStatus,proto3" json:"internal_task_queue_status,omitempty"`
	TaskQueueStats          *v13.TaskQueueStats        `protobuf:"bytes,2,opt,name=task_queue_stats,json=taskQueueStats,proto3" json:"task_queue_stats,omitempty"`
	// (-- api-linter: core::0140::prepositions=disabled
	//
	//	aip.dev/not-precedent: "by" is used to clarify the keys. --)
	TaskQueueStatsByPriorityKey map[int32]*v13.TaskQueueStats `protobuf:"bytes,4,rep,name=task_queue_stats_by_priority_key,json=taskQueueStatsByPriorityKey,proto3" json:"task_queue_stats_by_priority_key,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields               protoimpl.UnknownFields
	sizeCache                   protoimpl.SizeCache
}

func (x *PhysicalTaskQueueInfo) Reset() {
	*x = PhysicalTaskQueueInfo{}
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PhysicalTaskQueueInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PhysicalTaskQueueInfo) ProtoMessage() {}

func (x *PhysicalTaskQueueInfo) ProtoReflect() protoreflect.Message {
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PhysicalTaskQueueInfo.ProtoReflect.Descriptor instead.
func (*PhysicalTaskQueueInfo) Descriptor() ([]byte, []int) {
	return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{4}
}

func (x *PhysicalTaskQueueInfo) GetPollers() []*v13.PollerInfo {
	if x != nil {
		return x.Pollers
	}
	return nil
}

func (x *PhysicalTaskQueueInfo) GetInternalTaskQueueStatus() []*InternalTaskQueueStatus {
	if x != nil {
		return x.InternalTaskQueueStatus
	}
	return nil
}

func (x *PhysicalTaskQueueInfo) GetTaskQueueStats() *v13.TaskQueueStats {
	if x != nil {
		return x.TaskQueueStats
	}
	return nil
}

func (x *PhysicalTaskQueueInfo) GetTaskQueueStatsByPriorityKey() map[int32]*v13.TaskQueueStats {
	if x != nil {
		return x.TaskQueueStatsByPriorityKey
	}
	return nil
}

// Represents a normal or sticky partition of a task queue.
type TaskQueuePartition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// This is the user-facing name for this task queue
	TaskQueue     string           `protobuf:"bytes,1,opt,name=task_queue,json=taskQueue,proto3" json:"task_queue,omitempty"`
	TaskQueueType v1.TaskQueueType `protobuf:"varint,2,opt,name=task_queue_type,json=taskQueueType,proto3,enum=temporal.api.enums.v1.TaskQueueType" json:"task_queue_type,omitempty"`
	// Absent means normal root partition (normal_partition_id=0)
	//
	// Types that are valid to be assigned to PartitionId:
	//
	//	*TaskQueuePartition_NormalPartitionId
	//	*TaskQueuePartition_StickyName
	PartitionId   isTaskQueuePartition_PartitionId `protobuf_oneof:"partition_id"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskQueuePartition) Reset() {
	*x = TaskQueuePartition{}
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TaskQueuePartition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TaskQueuePartition) ProtoMessage() {}

func (x *TaskQueuePartition) ProtoReflect() protoreflect.Message {
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TaskQueuePartition.ProtoReflect.Descriptor instead.
func (*TaskQueuePartition) Descriptor() ([]byte, []int) {
	return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{5}
}

func (x *TaskQueuePartition) GetTaskQueue() string {
	if x != nil {
		return x.TaskQueue
	}
	return ""
}

func (x *TaskQueuePartition) GetTaskQueueType() v1.TaskQueueType {
	if x != nil {
		return x.TaskQueueType
	}
	return v1.TaskQueueType(0)
}

func (x *TaskQueuePartition) GetPartitionId() isTaskQueuePartition_PartitionId {
	if x != nil {
		return x.PartitionId
	}
	return nil
}

func (x *TaskQueuePartition) GetNormalPartitionId() int32 {
	if x != nil {
		if x, ok := x.PartitionId.(*TaskQueuePartition_NormalPartitionId); ok {
			return x.NormalPartitionId
		}
	}
	return 0
}

func (x *TaskQueuePartition) GetStickyName() string {
	if x != nil {
		if x, ok := x.PartitionId.(*TaskQueuePartition_StickyName); ok {
			return x.StickyName
		}
	}
	return ""
}

type isTaskQueuePartition_PartitionId interface {
	isTaskQueuePartition_PartitionId()
}

type TaskQueuePartition_NormalPartitionId struct {
	NormalPartitionId int32 `protobuf:"varint,3,opt,name=normal_partition_id,json=normalPartitionId,proto3,oneof"`
}

type TaskQueuePartition_StickyName struct {
	StickyName string `protobuf:"bytes,4,opt,name=sticky_name,json=stickyName,proto3,oneof"`
}

func (*TaskQueuePartition_NormalPartitionId) isTaskQueuePartition_PartitionId() {}

func (*TaskQueuePartition_StickyName) isTaskQueuePartition_PartitionId() {}

// Information about redirect intention sent by Matching to History in Record*TaskStarted calls.
// Deprecated.
type BuildIdRedirectInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// build ID asked by History in the directive or the one calculated based on the assignment rules.
	// this is the source of the redirect rule chain applied. (the target of the redirect rule chain is
	// the poller's build ID reported in WorkerVersionCapabilities)
	AssignedBuildId string `protobuf:"bytes,1,opt,name=assigned_build_id,json=assignedBuildId,proto3" json:"assigned_build_id,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *BuildIdRedirectInfo) Reset() {
	*x = BuildIdRedirectInfo{}
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *BuildIdRedirectInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*BuildIdRedirectInfo) ProtoMessage() {}

func (x *BuildIdRedirectInfo) ProtoReflect() protoreflect.Message {
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use BuildIdRedirectInfo.ProtoReflect.Descriptor instead.
func (*BuildIdRedirectInfo) Descriptor() ([]byte, []int) {
	return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{6}
}

func (x *BuildIdRedirectInfo) GetAssignedBuildId() string {
	if x != nil {
		return x.AssignedBuildId
	}
	return ""
}

// Information about task forwarding from one partition to its parent.
type TaskForwardInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// RPC name of the partition forwarded the task.
	// In case of multiple hops, this is the source partition of the last hop.
	SourcePartition string         `protobuf:"bytes,1,opt,name=source_partition,json=sourcePartition,proto3" json:"source_partition,omitempty"`
	TaskSource      v14.TaskSource `protobuf:"varint,2,opt,name=task_source,json=taskSource,proto3,enum=temporal.server.api.enums.v1.TaskSource" json:"task_source,omitempty"`
	// Redirect info is not present for Query and Nexus tasks. Versioning decisions for activity/workflow
	// tasks are made at the source partition and sent to the parent partition in this message so that parent partition
	// does not have to make versioning decision again. For Query/Nexus tasks, this works differently as the child's
	// versioning decision is ignored and the parent partition makes a fresh decision.
	// Deprecated. [cleanup-old-wv]
	RedirectInfo *BuildIdRedirectInfo `protobuf:"bytes,3,opt,name=redirect_info,json=redirectInfo,proto3" json:"redirect_info,omitempty"`
	// Build ID that should be used to dispatch the task to. Ignored in Query and Nexus tasks.
	// Deprecated. [cleanup-old-wv]
	DispatchBuildId string `protobuf:"bytes,4,opt,name=dispatch_build_id,json=dispatchBuildId,proto3" json:"dispatch_build_id,omitempty"`
	// Only used for old versioning. [cleanup-old-wv]
	// Deprecated. [cleanup-old-wv]
	DispatchVersionSet string `protobuf:"bytes,5,opt,name=dispatch_version_set,json=dispatchVersionSet,proto3" json:"dispatch_version_set,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *TaskForwardInfo) Reset() {
	*x = TaskForwardInfo{}
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TaskForwardInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TaskForwardInfo) ProtoMessage() {}

func (x *TaskForwardInfo) ProtoReflect() protoreflect.Message {
	mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TaskForwardInfo.ProtoReflect.Descriptor instead.
func (*TaskForwardInfo) Descriptor() ([]byte, []int) {
	return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{7}
}

func (x *TaskForwardInfo) GetSourcePartition() string {
	if x != nil {
		return x.SourcePartition
	}
	return ""
}

func (x *TaskForwardInfo) GetTaskSource() v14.TaskSource {
	if x != nil {
		return x.TaskSource
	}
	return v14.TaskSource(0)
}

func (x *TaskForwardInfo) GetRedirectInfo() *BuildIdRedirectInfo {
	if x != nil {
		return x.RedirectInfo
	}
	return nil
}

func (x *TaskForwardInfo) GetDispatchBuildId() string {
	if x != nil {
		return x.DispatchBuildId
	}
	return ""
}

func (x *TaskForwardInfo) GetDispatchVersionSet() string {
	if x != nil {
		return x.DispatchVersionSet
	}
	return ""
}

var File_temporal_server_api_taskqueue_v1_message_proto protoreflect.FileDescriptor

const file_temporal_server_api_taskqueue_v1_message_proto_rawDesc = "" +
	"\n" +
	".temporal/server/api/taskqueue/v1/message.proto\x12 temporal.server.api.taskqueue.v1\x1a\x1bgoogle/protobuf/empty.proto\x1a(temporal/api/deployment/v1/message.proto\x1a&temporal/api/enums/v1/task_queue.proto\x1a$temporal/api/enums/v1/workflow.proto\x1a'temporal/api/taskqueue/v1/message.proto\x1a'temporal/server/api/enums/v1/task.proto\x1a/temporal/server/api/deployment/v1/message.proto\"\xbf\x03\n" +
	"\x14TaskVersionDirective\x12J\n" +
	"\x14use_assignment_rules\x18\x01 \x01(\v2\x16.google.protobuf.EmptyH\x00R\x12useAssignmentRules\x12,\n" +
	"\x11assigned_build_id\x18\x02 \x01(\tH\x00R\x0fassignedBuildId\x12E\n" +
	"\bbehavior\x18\x03 \x01(\x0e2).temporal.api.enums.v1.VersioningBehaviorR\bbehavior\x12F\n" +
	"\n" +
	"deployment\x18\x04 \x01(\v2&.temporal.api.deployment.v1.DeploymentR\n" +
	"deployment\x12i\n" +
	"\x12deployment_version\x18\x05 \x01(\v2:.temporal.server.api.deployment.v1.WorkerDeploymentVersionR\x11deploymentVersion\x12'\n" +
	"\x0frevision_number\x18\x06 \x01(\x03R\x0erevisionNumberB\n" +
	"\n" +
	"\bbuild_id\"A\n" +
	"\tFairLevel\x12\x1b\n" +
	"\ttask_pass\x18\x01 \x01(\x03R\btaskPass\x12\x17\n" +
	"\atask_id\x18\x02 \x01(\x03R\x06taskId\"\xc6\x04\n" +
	"\x17InternalTaskQueueStatus\x12\x1d\n" +
	"\n" +
	"read_level\x18\x01 \x01(\x03R\treadLevel\x12S\n" +
	"\x0ffair_read_level\x18\a \x01(\v2+.temporal.server.api.taskqueue.v1.FairLevelR\rfairReadLevel\x12\x1b\n" +
	"\tack_level\x18\x02 \x01(\x03R\backLevel\x12Q\n" +
	"\x0efair_ack_level\x18\b \x01(\v2+.temporal.server.api.taskqueue.v1.FairLevelR\ffairAckLevel\x12J\n" +
	"\rtask_id_block\x18\x03 \x01(\v2&.temporal.api.taskqueue.v1.TaskIdBlockR\vtaskIdBlock\x12!\n" +
	"\floaded_tasks\x18\x04 \x01(\x03R\vloadedTasks\x12:\n" +
	"\x19approximate_backlog_count\x18\x05 \x01(\x03R\x17approximateBacklogCount\x12$\n" +
	"\x0emax_read_level\x18\x06 \x01(\x03R\fmaxReadLevel\x12Z\n" +
	"\x13fair_max_read_level\x18\t \x01(\v2+.temporal.server.api.taskqueue.v1.FairLevelR\x10fairMaxReadLevel\x12\x1a\n" +
	"\bdraining\x18\n" +
	" \x01(\bR\bdraining\"\x90\x01\n" +
	"\x1cTaskQueueVersionInfoInternal\x12p\n" +
	"\x18physical_task_queue_info\x18\x02 \x01(\v27.temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfoR\x15physicalTaskQueueInfo\"\xc2\x04\n" +
	"\x15PhysicalTaskQueueInfo\x12?\n" +
	"\apollers\x18\x01 \x03(\v2%.temporal.api.taskqueue.v1.PollerInfoR\apollers\x12v\n" +
	"\x1ainternal_task_queue_status\x18\x03 \x03(\v29.temporal.server.api.taskqueue.v1.InternalTaskQueueStatusR\x17internalTaskQueueStatus\x12S\n" +
	"\x10task_queue_stats\x18\x02 \x01(\v2).temporal.api.taskqueue.v1.TaskQueueStatsR\x0etaskQueueStats\x12\x9f\x01\n" +
	" task_queue_stats_by_priority_key\x18\x04 \x03(\v2X.temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.TaskQueueStatsByPriorityKeyEntryR\x1btaskQueueStatsByPriorityKey\x1ay\n" +
	" TaskQueueStatsByPriorityKeyEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12?\n" +
	"\x05value\x18\x02 \x01(\v2).temporal.api.taskqueue.v1.TaskQueueStatsR\x05value:\x028\x01\"\xe6\x01\n" +
	"\x12TaskQueuePartition\x12\x1d\n" +
	"\n" +
	"task_queue\x18\x01 \x01(\tR\ttaskQueue\x12L\n" +
	"\x0ftask_queue_type\x18\x02 \x01(\x0e2$.temporal.api.enums.v1.TaskQueueTypeR\rtaskQueueType\x120\n" +
	"\x13normal_partition_id\x18\x03 \x01(\x05H\x00R\x11normalPartitionId\x12!\n" +
	"\vsticky_name\x18\x04 \x01(\tH\x00R\n" +
	"stickyNameB\x0e\n" +
	"\fpartition_id\"A\n" +
	"\x13BuildIdRedirectInfo\x12*\n" +
	"\x11assigned_build_id\x18\x01 \x01(\tR\x0fassignedBuildId\"\xc1\x02\n" +
	"\x0fTaskForwardInfo\x12)\n" +
	"\x10source_partition\x18\x01 \x01(\tR\x0fsourcePartition\x12I\n" +
	"\vtask_source\x18\x02 \x01(\x0e2(.temporal.server.api.enums.v1.TaskSourceR\n" +
	"taskSource\x12Z\n" +
	"\rredirect_info\x18\x03 \x01(\v25.temporal.server.api.taskqueue.v1.BuildIdRedirectInfoR\fredirectInfo\x12*\n" +
	"\x11dispatch_build_id\x18\x04 \x01(\tR\x0fdispatchBuildId\x120\n" +
	"\x14dispatch_version_set\x18\x05 \x01(\tR\x12dispatchVersionSetB2Z0go.temporal.io/server/api/taskqueue/v1;taskqueueb\x06proto3"

var (
	file_temporal_server_api_taskqueue_v1_message_proto_rawDescOnce sync.Once
	file_temporal_server_api_taskqueue_v1_message_proto_rawDescData []byte
)

func file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP() []byte {
	file_temporal_server_api_taskqueue_v1_message_proto_rawDescOnce.Do(func() {
		file_temporal_server_api_taskqueue_v1_message_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc), len(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc)))
	})
	return file_temporal_server_api_taskqueue_v1_message_proto_rawDescData
}

var file_temporal_server_api_taskqueue_v1_message_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
var file_temporal_server_api_taskqueue_v1_message_proto_goTypes = []any{
	(*TaskVersionDirective)(nil),         // 0: temporal.server.api.taskqueue.v1.TaskVersionDirective
	(*FairLevel)(nil),                    // 1: temporal.server.api.taskqueue.v1.FairLevel
	(*InternalTaskQueueStatus)(nil),      // 2: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus
	(*TaskQueueVersionInfoInternal)(nil), // 3: temporal.server.api.taskqueue.v1.TaskQueueVersionInfoInternal
	(*PhysicalTaskQueueInfo)(nil),        // 4: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo
	(*TaskQueuePartition)(nil),           // 5: temporal.server.api.taskqueue.v1.TaskQueuePartition
	(*BuildIdRedirectInfo)(nil),          // 6: temporal.server.api.taskqueue.v1.BuildIdRedirectInfo
	(*TaskForwardInfo)(nil),              // 7: temporal.server.api.taskqueue.v1.TaskForwardInfo
	nil,                                  // 8: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.TaskQueueStatsByPriorityKeyEntry
	(*emptypb.Empty)(nil),                // 9: google.protobuf.Empty
	(v1.VersioningBehavior)(0),           // 10: temporal.api.enums.v1.VersioningBehavior
	(*v11.Deployment)(nil),               // 11: temporal.api.deployment.v1.Deployment
	(*v12.WorkerDeploymentVersion)(nil),  // 12: temporal.server.api.deployment.v1.WorkerDeploymentVersion
	(*v13.TaskIdBlock)(nil),              // 13: temporal.api.taskqueue.v1.TaskIdBlock
	(*v13.PollerInfo)(nil),               // 14: temporal.api.taskqueue.v1.PollerInfo
	(*v13.TaskQueueStats)(nil),           // 15: temporal.api.taskqueue.v1.TaskQueueStats
	(v1.TaskQueueType)(0),                // 16: temporal.api.enums.v1.TaskQueueType
	(v14.TaskSource)(0),                  // 17: temporal.server.api.enums.v1.TaskSource
}
var file_temporal_server_api_taskqueue_v1_message_proto_depIdxs = []int32{
	9,  // 0: temporal.server.api.taskqueue.v1.TaskVersionDirective.use_assignment_rules:type_name -> google.protobuf.Empty
	10, // 1: temporal.server.api.taskqueue.v1.TaskVersionDirective.behavior:type_name -> temporal.api.enums.v1.VersioningBehavior
	11, // 2: temporal.server.api.taskqueue.v1.TaskVersionDirective.deployment:type_name -> temporal.api.deployment.v1.Deployment
	12, // 3: temporal.server.api.taskqueue.v1.TaskVersionDirective.deployment_version:type_name -> temporal.server.api.deployment.v1.WorkerDeploymentVersion
	1,  // 4: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus.fair_read_level:type_name -> temporal.server.api.taskqueue.v1.FairLevel
	1,  // 5: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus.fair_ack_level:type_name -> temporal.server.api.taskqueue.v1.FairLevel
	13, // 6: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus.task_id_block:type_name -> temporal.api.taskqueue.v1.TaskIdBlock
	1,  // 7: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus.fair_max_read_level:type_name -> temporal.server.api.taskqueue.v1.FairLevel
	4,  // 8: temporal.server.api.taskqueue.v1.TaskQueueVersionInfoInternal.physical_task_queue_info:type_name -> temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo
	14, // 9: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.pollers:type_name -> temporal.api.taskqueue.v1.PollerInfo
	2,  // 10: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.internal_task_queue_status:type_name -> temporal.server.api.taskqueue.v1.InternalTaskQueueStatus
	15, // 11: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.task_queue_stats:type_name -> temporal.api.taskqueue.v1.TaskQueueStats
	8,  // 12: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.task_queue_stats_by_priority_key:type_name -> temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.TaskQueueStatsByPriorityKeyEntry
	16, // 13: temporal.server.api.taskqueue.v1.TaskQueuePartition.task_queue_type:type_name -> temporal.api.enums.v1.TaskQueueType
	17, // 14: temporal.server.api.taskqueue.v1.TaskForwardInfo.task_source:type_name -> temporal.server.api.enums.v1.TaskSource
	6,  // 15: temporal.server.api.taskqueue.v1.TaskForwardInfo.redirect_info:type_name -> temporal.server.api.taskqueue.v1.BuildIdRedirectInfo
	15, // 16: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.TaskQueueStatsByPriorityKeyEntry.value:type_name -> temporal.api.taskqueue.v1.TaskQueueStats
	17, // [17:17] is the sub-list for method output_type
	17, // [17:17] is the sub-list for method input_type
	17, // [17:17] is the sub-list for extension type_name
	17, // [17:17] is the sub-list for extension extendee
	0,  // [0:17] is the sub-list for field type_name
}

func init() { file_temporal_server_api_taskqueue_v1_message_proto_init() }
func file_temporal_server_api_taskqueue_v1_message_proto_init() {
	if File_temporal_server_api_taskqueue_v1_message_proto != nil {
		return
	}
	file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0].OneofWrappers = []any{
		(*TaskVersionDirective_UseAssignmentRules)(nil),
		(*TaskVersionDirective_AssignedBuildId)(nil),
	}
	file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5].OneofWrappers = []any{
		(*TaskQueuePartition_NormalPartitionId)(nil),
		(*TaskQueuePartition_StickyName)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc), len(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   9,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_temporal_server_api_taskqueue_v1_message_proto_goTypes,
		DependencyIndexes: file_temporal_server_api_taskqueue_v1_message_proto_depIdxs,
		MessageInfos:      file_temporal_server_api_taskqueue_v1_message_proto_msgTypes,
	}.Build()
	File_temporal_server_api_taskqueue_v1_message_proto = out.File
	file_temporal_server_api_taskqueue_v1_message_proto_goTypes = nil
	file_temporal_server_api_taskqueue_v1_message_proto_depIdxs = nil
}