Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

132 KB
Raw Blame
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.12
// 	protoc        (unknown)
// source: v1/rollout_service.proto

package v1

import (
	_ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

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)
)

type Task_Status int32

const (
	// Unspecified status.
	Task_STATUS_UNSPECIFIED Task_Status = 0
	// Task has not started and is awaiting its turn in the deployment sequence.
	Task_NOT_STARTED Task_Status = 1
	// Task is ready to run and waiting for approval or scheduled time.
	Task_PENDING Task_Status = 2
	// Task is currently executing.
	Task_RUNNING Task_Status = 3
	// Task completed successfully.
	Task_DONE Task_Status = 4
	// Task execution failed with errors.
	Task_FAILED Task_Status = 5
	// Task execution was canceled by a user.
	Task_CANCELED Task_Status = 6
	// Task was skipped and will not be executed.
	Task_SKIPPED Task_Status = 7
)

// Enum value maps for Task_Status.
var (
	Task_Status_name = map[int32]string{
		0: "STATUS_UNSPECIFIED",
		1: "NOT_STARTED",
		2: "PENDING",
		3: "RUNNING",
		4: "DONE",
		5: "FAILED",
		6: "CANCELED",
		7: "SKIPPED",
	}
	Task_Status_value = map[string]int32{
		"STATUS_UNSPECIFIED": 0,
		"NOT_STARTED":        1,
		"PENDING":            2,
		"RUNNING":            3,
		"DONE":               4,
		"FAILED":             5,
		"CANCELED":           6,
		"SKIPPED":            7,
	}
)

func (x Task_Status) Enum() *Task_Status {
	p := new(Task_Status)
	*p = x
	return p
}

func (x Task_Status) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Task_Status) Descriptor() protoreflect.EnumDescriptor {
	return file_v1_rollout_service_proto_enumTypes[0].Descriptor()
}

func (Task_Status) Type() protoreflect.EnumType {
	return &file_v1_rollout_service_proto_enumTypes[0]
}

func (x Task_Status) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Task_Status.Descriptor instead.
func (Task_Status) EnumDescriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{16, 0}
}

type Task_Type int32

const (
	// Unspecified task type.
	Task_TYPE_UNSPECIFIED Task_Type = 0
	// General task for miscellaneous operations.
	Task_GENERAL Task_Type = 1
	// Database creation task that creates a new database.
	// Use payload DatabaseCreate.
	Task_DATABASE_CREATE Task_Type = 2
	// Database migration task that applies versioned schema changes.
	// Use payload DatabaseUpdate.
	Task_DATABASE_MIGRATE Task_Type = 3
)

// Enum value maps for Task_Type.
var (
	Task_Type_name = map[int32]string{
		0: "TYPE_UNSPECIFIED",
		1: "GENERAL",
		2: "DATABASE_CREATE",
		3: "DATABASE_MIGRATE",
	}
	Task_Type_value = map[string]int32{
		"TYPE_UNSPECIFIED": 0,
		"GENERAL":          1,
		"DATABASE_CREATE":  2,
		"DATABASE_MIGRATE": 3,
	}
)

func (x Task_Type) Enum() *Task_Type {
	p := new(Task_Type)
	*p = x
	return p
}

func (x Task_Type) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Task_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_v1_rollout_service_proto_enumTypes[1].Descriptor()
}

func (Task_Type) Type() protoreflect.EnumType {
	return &file_v1_rollout_service_proto_enumTypes[1]
}

func (x Task_Type) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Task_Type.Descriptor instead.
func (Task_Type) EnumDescriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{16, 1}
}

type TaskRun_Status int32

const (
	// Unspecified status.
	TaskRun_STATUS_UNSPECIFIED TaskRun_Status = 0
	// Task run is queued and waiting to start execution.
	TaskRun_PENDING TaskRun_Status = 1
	// Task run is currently executing.
	TaskRun_RUNNING TaskRun_Status = 2
	// Task run completed successfully.
	TaskRun_DONE TaskRun_Status = 3
	// Task run execution failed with errors.
	TaskRun_FAILED TaskRun_Status = 4
	// Task run execution was canceled by a user.
	TaskRun_CANCELED TaskRun_Status = 5
	// Task run is ready for immediate execution.
	TaskRun_AVAILABLE TaskRun_Status = 6
)

// Enum value maps for TaskRun_Status.
var (
	TaskRun_Status_name = map[int32]string{
		0: "STATUS_UNSPECIFIED",
		1: "PENDING",
		2: "RUNNING",
		3: "DONE",
		4: "FAILED",
		5: "CANCELED",
		6: "AVAILABLE",
	}
	TaskRun_Status_value = map[string]int32{
		"STATUS_UNSPECIFIED": 0,
		"PENDING":            1,
		"RUNNING":            2,
		"DONE":               3,
		"FAILED":             4,
		"CANCELED":           5,
		"AVAILABLE":          6,
	}
)

func (x TaskRun_Status) Enum() *TaskRun_Status {
	p := new(TaskRun_Status)
	*p = x
	return p
}

func (x TaskRun_Status) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (TaskRun_Status) Descriptor() protoreflect.EnumDescriptor {
	return file_v1_rollout_service_proto_enumTypes[2].Descriptor()
}

func (TaskRun_Status) Type() protoreflect.EnumType {
	return &file_v1_rollout_service_proto_enumTypes[2]
}

func (x TaskRun_Status) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use TaskRun_Status.Descriptor instead.
func (TaskRun_Status) EnumDescriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{17, 0}
}

// The type of log entry.
type TaskRunLogEntry_Type int32

const (
	// Unspecified type.
	TaskRunLogEntry_TYPE_UNSPECIFIED TaskRunLogEntry_Type = 0
	// Schema dump operation.
	TaskRunLogEntry_SCHEMA_DUMP TaskRunLogEntry_Type = 1
	// Command execution.
	TaskRunLogEntry_COMMAND_EXECUTE TaskRunLogEntry_Type = 2
	// Database synchronization.
	TaskRunLogEntry_DATABASE_SYNC TaskRunLogEntry_Type = 3
	// Transaction control (BEGIN, COMMIT, ROLLBACK).
	TaskRunLogEntry_TRANSACTION_CONTROL TaskRunLogEntry_Type = 5
	// Prior backup operation.
	TaskRunLogEntry_PRIOR_BACKUP TaskRunLogEntry_Type = 6
	// Retry information.
	TaskRunLogEntry_RETRY_INFO TaskRunLogEntry_Type = 7
	// Schema diff computation.
	TaskRunLogEntry_COMPUTE_DIFF TaskRunLogEntry_Type = 8
	// Release file execution.
	TaskRunLogEntry_RELEASE_FILE_EXECUTE TaskRunLogEntry_Type = 9
	// gh-ost online migration.
	TaskRunLogEntry_GHOST_MIGRATION TaskRunLogEntry_Type = 10
)

// Enum value maps for TaskRunLogEntry_Type.
var (
	TaskRunLogEntry_Type_name = map[int32]string{
		0:  "TYPE_UNSPECIFIED",
		1:  "SCHEMA_DUMP",
		2:  "COMMAND_EXECUTE",
		3:  "DATABASE_SYNC",
		5:  "TRANSACTION_CONTROL",
		6:  "PRIOR_BACKUP",
		7:  "RETRY_INFO",
		8:  "COMPUTE_DIFF",
		9:  "RELEASE_FILE_EXECUTE",
		10: "GHOST_MIGRATION",
	}
	TaskRunLogEntry_Type_value = map[string]int32{
		"TYPE_UNSPECIFIED":     0,
		"SCHEMA_DUMP":          1,
		"COMMAND_EXECUTE":      2,
		"DATABASE_SYNC":        3,
		"TRANSACTION_CONTROL":  5,
		"PRIOR_BACKUP":         6,
		"RETRY_INFO":           7,
		"COMPUTE_DIFF":         8,
		"RELEASE_FILE_EXECUTE": 9,
		"GHOST_MIGRATION":      10,
	}
)

func (x TaskRunLogEntry_Type) Enum() *TaskRunLogEntry_Type {
	p := new(TaskRunLogEntry_Type)
	*p = x
	return p
}

func (x TaskRunLogEntry_Type) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (TaskRunLogEntry_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_v1_rollout_service_proto_enumTypes[3].Descriptor()
}

func (TaskRunLogEntry_Type) Type() protoreflect.EnumType {
	return &file_v1_rollout_service_proto_enumTypes[3]
}

func (x TaskRunLogEntry_Type) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use TaskRunLogEntry_Type.Descriptor instead.
func (TaskRunLogEntry_Type) EnumDescriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 0}
}

// Transaction control type.
type TaskRunLogEntry_TransactionControl_Type int32

const (
	// Unspecified type.
	TaskRunLogEntry_TransactionControl_TYPE_UNSPECIFIED TaskRunLogEntry_TransactionControl_Type = 0
	// Begin transaction.
	TaskRunLogEntry_TransactionControl_BEGIN TaskRunLogEntry_TransactionControl_Type = 1
	// Commit transaction.
	TaskRunLogEntry_TransactionControl_COMMIT TaskRunLogEntry_TransactionControl_Type = 2
	// Rollback transaction.
	TaskRunLogEntry_TransactionControl_ROLLBACK TaskRunLogEntry_TransactionControl_Type = 3
)

// Enum value maps for TaskRunLogEntry_TransactionControl_Type.
var (
	TaskRunLogEntry_TransactionControl_Type_name = map[int32]string{
		0: "TYPE_UNSPECIFIED",
		1: "BEGIN",
		2: "COMMIT",
		3: "ROLLBACK",
	}
	TaskRunLogEntry_TransactionControl_Type_value = map[string]int32{
		"TYPE_UNSPECIFIED": 0,
		"BEGIN":            1,
		"COMMIT":           2,
		"ROLLBACK":         3,
	}
)

func (x TaskRunLogEntry_TransactionControl_Type) Enum() *TaskRunLogEntry_TransactionControl_Type {
	p := new(TaskRunLogEntry_TransactionControl_Type)
	*p = x
	return p
}

func (x TaskRunLogEntry_TransactionControl_Type) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (TaskRunLogEntry_TransactionControl_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_v1_rollout_service_proto_enumTypes[4].Descriptor()
}

func (TaskRunLogEntry_TransactionControl_Type) Type() protoreflect.EnumType {
	return &file_v1_rollout_service_proto_enumTypes[4]
}

func (x TaskRunLogEntry_TransactionControl_Type) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use TaskRunLogEntry_TransactionControl_Type.Descriptor instead.
func (TaskRunLogEntry_TransactionControl_Type) EnumDescriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 3, 0}
}

type BatchRunTasksRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The stage name for the tasks.
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The tasks to run.
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}
	Tasks []string `protobuf:"bytes,2,rep,name=tasks,proto3" json:"tasks,omitempty"`
	// The task run should run after run_time.
	RunTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=run_time,json=runTime,proto3,oneof" json:"run_time,omitempty"`
	// If true, skip prior backup for this run even if the task has prior backup enabled.
	SkipPriorBackup bool `protobuf:"varint,4,opt,name=skip_prior_backup,json=skipPriorBackup,proto3" json:"skip_prior_backup,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*BatchRunTasksRequest) ProtoMessage() {}

func (x *BatchRunTasksRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_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 BatchRunTasksRequest.ProtoReflect.Descriptor instead.
func (*BatchRunTasksRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{0}
}

func (x *BatchRunTasksRequest) GetParent() string {
	if x != nil {
		return x.Parent
	}
	return ""
}

func (x *BatchRunTasksRequest) GetTasks() []string {
	if x != nil {
		return x.Tasks
	}
	return nil
}

func (x *BatchRunTasksRequest) GetRunTime() *timestamppb.Timestamp {
	if x != nil {
		return x.RunTime
	}
	return nil
}

func (x *BatchRunTasksRequest) GetSkipPriorBackup() bool {
	if x != nil {
		return x.SkipPriorBackup
	}
	return false
}

type BatchRunTasksResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchRunTasksResponse) ProtoMessage() {}

func (x *BatchRunTasksResponse) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_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 BatchRunTasksResponse.ProtoReflect.Descriptor instead.
func (*BatchRunTasksResponse) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{1}
}

type BatchSkipTasksRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The stage name for the tasks.
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The tasks to skip.
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}
	Tasks []string `protobuf:"bytes,2,rep,name=tasks,proto3" json:"tasks,omitempty"`
	// The reason for skipping the tasks.
	Reason        string `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchSkipTasksRequest) ProtoMessage() {}

func (x *BatchSkipTasksRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_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 BatchSkipTasksRequest.ProtoReflect.Descriptor instead.
func (*BatchSkipTasksRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{2}
}

func (x *BatchSkipTasksRequest) GetParent() string {
	if x != nil {
		return x.Parent
	}
	return ""
}

func (x *BatchSkipTasksRequest) GetTasks() []string {
	if x != nil {
		return x.Tasks
	}
	return nil
}

func (x *BatchSkipTasksRequest) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

type BatchSkipTasksResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchSkipTasksResponse) ProtoMessage() {}

func (x *BatchSkipTasksResponse) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_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 BatchSkipTasksResponse.ProtoReflect.Descriptor instead.
func (*BatchSkipTasksResponse) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{3}
}

type BatchCancelTaskRunsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The task name for the taskRuns.
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}
	// Use `projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/-` to cancel task runs under the same stage.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The taskRuns to cancel.
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}
	TaskRuns      []string `protobuf:"bytes,2,rep,name=task_runs,json=taskRuns,proto3" json:"task_runs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchCancelTaskRunsRequest) ProtoMessage() {}

func (x *BatchCancelTaskRunsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_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 BatchCancelTaskRunsRequest.ProtoReflect.Descriptor instead.
func (*BatchCancelTaskRunsRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{4}
}

func (x *BatchCancelTaskRunsRequest) GetParent() string {
	if x != nil {
		return x.Parent
	}
	return ""
}

func (x *BatchCancelTaskRunsRequest) GetTaskRuns() []string {
	if x != nil {
		return x.TaskRuns
	}
	return nil
}

type BatchCancelTaskRunsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchCancelTaskRunsResponse) ProtoMessage() {}

func (x *BatchCancelTaskRunsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_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 BatchCancelTaskRunsResponse.ProtoReflect.Descriptor instead.
func (*BatchCancelTaskRunsResponse) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{5}
}

type GetRolloutRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the rollout to retrieve.
	// This is the rollout resource name, which is the plan name plus /rollout suffix.
	// Format: projects/{project}/plans/{plan}/rollout
	Name          string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetRolloutRequest) ProtoMessage() {}

func (x *GetRolloutRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_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 GetRolloutRequest.ProtoReflect.Descriptor instead.
func (*GetRolloutRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{6}
}

func (x *GetRolloutRequest) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

type ListRolloutsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The parent, which owns this collection of rollouts.
	// Format: projects/{project}
	// Use "projects/-" to list all rollouts from all projects.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The maximum number of rollouts to return. The service may return fewer than
	// this value.
	// If unspecified, at most 10 rollouts will be returned.
	// The maximum value is 1000; values above 1000 will be coerced to 1000.
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// A page token, received from a previous `ListRollouts` call.
	// Provide this to retrieve the subsequent page.
	//
	// When paginating, all other parameters provided to `ListRollouts` must match
	// the call that provided the page token.
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// Filter is used to filter rollouts returned in the list.
	// The syntax and semantics of CEL are documented at https://github.com/google/cel-spec
	//
	// Supported filters:
	// - update_time: rollout update time in "2006-01-02T15:04:05Z07:00" format, support ">=" or "<=" operator.
	// - task_type: the task type, support "in" operator, check the Task.Type enum for the values.
	//
	// For example:
	// update_time >= "2025-01-02T15:04:05Z07:00"
	// task_type in ["DATABASE_MIGRATE", "DATABASE_CREATE"]
	Filter        string `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListRolloutsRequest) ProtoMessage() {}

func (x *ListRolloutsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_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 ListRolloutsRequest.ProtoReflect.Descriptor instead.
func (*ListRolloutsRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{7}
}

func (x *ListRolloutsRequest) GetParent() string {
	if x != nil {
		return x.Parent
	}
	return ""
}

func (x *ListRolloutsRequest) GetPageSize() int32 {
	if x != nil {
		return x.PageSize
	}
	return 0
}

func (x *ListRolloutsRequest) GetPageToken() string {
	if x != nil {
		return x.PageToken
	}
	return ""
}

func (x *ListRolloutsRequest) GetFilter() string {
	if x != nil {
		return x.Filter
	}
	return ""
}

type ListRolloutsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The rollouts from the specified request.
	Rollouts []*Rollout `protobuf:"bytes,1,rep,name=rollouts,proto3" json:"rollouts,omitempty"`
	// A token, which can be sent as `page_token` to retrieve the next page.
	// If this field is omitted, there are no subsequent pages.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListRolloutsResponse) Reset() {
	*x = ListRolloutsResponse{}
	mi := &file_v1_rollout_service_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListRolloutsResponse) ProtoMessage() {}

func (x *ListRolloutsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[8]
	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 ListRolloutsResponse.ProtoReflect.Descriptor instead.
func (*ListRolloutsResponse) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{8}
}

func (x *ListRolloutsResponse) GetRollouts() []*Rollout {
	if x != nil {
		return x.Rollouts
	}
	return nil
}

func (x *ListRolloutsResponse) GetNextPageToken() string {
	if x != nil {
		return x.NextPageToken
	}
	return ""
}

type CreateRolloutRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The parent plan for which this rollout will be created.
	// Format: projects/{project}/plans/{plan}
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// Create the rollout only for the specified target.
	// Format: environments/{environment}
	// If unspecified, all stages are created.
	// If set to "", no stages are created.
	Target        *string `protobuf:"bytes,3,opt,name=target,proto3,oneof" json:"target,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateRolloutRequest) Reset() {
	*x = CreateRolloutRequest{}
	mi := &file_v1_rollout_service_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateRolloutRequest) ProtoMessage() {}

func (x *CreateRolloutRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[9]
	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 CreateRolloutRequest.ProtoReflect.Descriptor instead.
func (*CreateRolloutRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{9}
}

func (x *CreateRolloutRequest) GetParent() string {
	if x != nil {
		return x.Parent
	}
	return ""
}

func (x *CreateRolloutRequest) GetTarget() string {
	if x != nil && x.Target != nil {
		return *x.Target
	}
	return ""
}

type ListTaskRunsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The parent, which owns this collection of taskRuns.
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}
	// Use "projects/{project}/plans/{plan}/rollout/stages/-/tasks/-" to list all taskRuns from a rollout.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The maximum number of task runs to return. The service may return fewer
	// than this value.
	// If unspecified, at most 1000 task runs will be returned.
	// The maximum value is 1000; values above 1000 will be coerced to 1000.
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// A page token, received from a previous `ListTaskRuns` call.
	// Provide this to retrieve the subsequent page.
	//
	// When paginating, all other parameters provided to `ListTaskRuns` must match
	// the call that provided the page token.
	PageToken     string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListTaskRunsRequest) Reset() {
	*x = ListTaskRunsRequest{}
	mi := &file_v1_rollout_service_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListTaskRunsRequest) ProtoMessage() {}

func (x *ListTaskRunsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[10]
	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 ListTaskRunsRequest.ProtoReflect.Descriptor instead.
func (*ListTaskRunsRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{10}
}

func (x *ListTaskRunsRequest) GetParent() string {
	if x != nil {
		return x.Parent
	}
	return ""
}

func (x *ListTaskRunsRequest) GetPageSize() int32 {
	if x != nil {
		return x.PageSize
	}
	return 0
}

func (x *ListTaskRunsRequest) GetPageToken() string {
	if x != nil {
		return x.PageToken
	}
	return ""
}

type ListTaskRunsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The taskRuns from the specified request.
	TaskRuns []*TaskRun `protobuf:"bytes,1,rep,name=task_runs,json=taskRuns,proto3" json:"task_runs,omitempty"`
	// A token, which can be sent as `page_token` to retrieve the next page.
	// If this field is omitted, there are no subsequent pages.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListTaskRunsResponse) Reset() {
	*x = ListTaskRunsResponse{}
	mi := &file_v1_rollout_service_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListTaskRunsResponse) ProtoMessage() {}

func (x *ListTaskRunsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[11]
	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 ListTaskRunsResponse.ProtoReflect.Descriptor instead.
func (*ListTaskRunsResponse) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{11}
}

func (x *ListTaskRunsResponse) GetTaskRuns() []*TaskRun {
	if x != nil {
		return x.TaskRuns
	}
	return nil
}

func (x *ListTaskRunsResponse) GetNextPageToken() string {
	if x != nil {
		return x.NextPageToken
	}
	return ""
}

type GetTaskRunRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}
	Name          string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetTaskRunRequest) Reset() {
	*x = GetTaskRunRequest{}
	mi := &file_v1_rollout_service_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetTaskRunRequest) ProtoMessage() {}

func (x *GetTaskRunRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[12]
	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 GetTaskRunRequest.ProtoReflect.Descriptor instead.
func (*GetTaskRunRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{12}
}

func (x *GetTaskRunRequest) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

type GetTaskRunLogRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}
	Parent        string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetTaskRunLogRequest) Reset() {
	*x = GetTaskRunLogRequest{}
	mi := &file_v1_rollout_service_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetTaskRunLogRequest) ProtoMessage() {}

func (x *GetTaskRunLogRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[13]
	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 GetTaskRunLogRequest.ProtoReflect.Descriptor instead.
func (*GetTaskRunLogRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{13}
}

func (x *GetTaskRunLogRequest) GetParent() string {
	if x != nil {
		return x.Parent
	}
	return ""
}

type Rollout struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The resource name of the rollout.
	// Format: projects/{project}/plans/{plan}/rollout
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The title of the rollout, inherited from the associated plan.
	// This field is output only and cannot be directly set.
	Title string `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"`
	// Stages and thus tasks of the rollout.
	Stages        []*Stage               `protobuf:"bytes,4,rep,name=stages,proto3" json:"stages,omitempty"`
	CreateTime    *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	UpdateTime    *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Rollout) Reset() {
	*x = Rollout{}
	mi := &file_v1_rollout_service_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Rollout) ProtoMessage() {}

func (x *Rollout) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[14]
	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 Rollout.ProtoReflect.Descriptor instead.
func (*Rollout) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{14}
}

func (x *Rollout) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Rollout) GetTitle() string {
	if x != nil {
		return x.Title
	}
	return ""
}

func (x *Rollout) GetStages() []*Stage {
	if x != nil {
		return x.Stages
	}
	return nil
}

func (x *Rollout) GetCreateTime() *timestamppb.Timestamp {
	if x != nil {
		return x.CreateTime
	}
	return nil
}

func (x *Rollout) GetUpdateTime() *timestamppb.Timestamp {
	if x != nil {
		return x.UpdateTime
	}
	return nil
}

type Stage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}
	// Use "-" for {stage} when the stage has no environment or deleted environment.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// id is the environment id of the stage.
	// e.g., "prod".
	// Use "-" when the stage has no environment or deleted environment.
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	// environment is the environment of the stage.
	// Format: environments/{environment} for valid environments, or "environments/-" for stages without environment or with deleted environments.
	Environment string `protobuf:"bytes,3,opt,name=environment,proto3" json:"environment,omitempty"`
	// The tasks within this stage.
	Tasks         []*Task `protobuf:"bytes,4,rep,name=tasks,proto3" json:"tasks,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Stage) Reset() {
	*x = Stage{}
	mi := &file_v1_rollout_service_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Stage) ProtoMessage() {}

func (x *Stage) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[15]
	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 Stage.ProtoReflect.Descriptor instead.
func (*Stage) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{15}
}

func (x *Stage) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Stage) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *Stage) GetEnvironment() string {
	if x != nil {
		return x.Environment
	}
	return ""
}

func (x *Stage) GetTasks() []*Task {
	if x != nil {
		return x.Tasks
	}
	return nil
}

type Task struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A UUID4 string that uniquely identifies the Spec.
	SpecId string `protobuf:"bytes,2,opt,name=spec_id,json=specId,proto3" json:"spec_id,omitempty"`
	// Status is the status of the task.
	Status Task_Status `protobuf:"varint,3,opt,name=status,proto3,enum=bytebase.v1.Task_Status" json:"status,omitempty"`
	// The reason why the task was skipped.
	SkippedReason string    `protobuf:"bytes,4,opt,name=skipped_reason,json=skippedReason,proto3" json:"skipped_reason,omitempty"`
	Type          Task_Type `protobuf:"varint,5,opt,name=type,proto3,enum=bytebase.v1.Task_Type" json:"type,omitempty"`
	// Format: instances/{instance} or projects/{project}/instances/{instance} if the task is DatabaseCreate.
	// Format: instances/{instance}/databases/{database} or projects/{project}/instances/{instance}/databases/{database}
	Target string `protobuf:"bytes,6,opt,name=target,proto3" json:"target,omitempty"`
	// Types that are valid to be assigned to Payload:
	//
	//	*Task_DatabaseCreate_
	//	*Task_DatabaseUpdate_
	Payload isTask_Payload `protobuf_oneof:"payload"`
	// The update_time is the update time of latest task run.
	// If there are no task runs, it will be empty.
	UpdateTime *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=update_time,json=updateTime,proto3,oneof" json:"update_time,omitempty"`
	// The run_time is the scheduled run time of latest task run.
	// If there are no task runs or the task run is not scheduled, it will be empty.
	RunTime       *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=run_time,json=runTime,proto3,oneof" json:"run_time,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Task) Reset() {
	*x = Task{}
	mi := &file_v1_rollout_service_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Task) ProtoMessage() {}

func (x *Task) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[16]
	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 Task.ProtoReflect.Descriptor instead.
func (*Task) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{16}
}

func (x *Task) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Task) GetSpecId() string {
	if x != nil {
		return x.SpecId
	}
	return ""
}

func (x *Task) GetStatus() Task_Status {
	if x != nil {
		return x.Status
	}
	return Task_STATUS_UNSPECIFIED
}

func (x *Task) GetSkippedReason() string {
	if x != nil {
		return x.SkippedReason
	}
	return ""
}

func (x *Task) GetType() Task_Type {
	if x != nil {
		return x.Type
	}
	return Task_TYPE_UNSPECIFIED
}

func (x *Task) GetTarget() string {
	if x != nil {
		return x.Target
	}
	return ""
}

func (x *Task) GetPayload() isTask_Payload {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *Task) GetDatabaseCreate() *Task_DatabaseCreate {
	if x != nil {
		if x, ok := x.Payload.(*Task_DatabaseCreate_); ok {
			return x.DatabaseCreate
		}
	}
	return nil
}

func (x *Task) GetDatabaseUpdate() *Task_DatabaseUpdate {
	if x != nil {
		if x, ok := x.Payload.(*Task_DatabaseUpdate_); ok {
			return x.DatabaseUpdate
		}
	}
	return nil
}

func (x *Task) GetUpdateTime() *timestamppb.Timestamp {
	if x != nil {
		return x.UpdateTime
	}
	return nil
}

func (x *Task) GetRunTime() *timestamppb.Timestamp {
	if x != nil {
		return x.RunTime
	}
	return nil
}

type isTask_Payload interface {
	isTask_Payload()
}

type Task_DatabaseCreate_ struct {
	DatabaseCreate *Task_DatabaseCreate `protobuf:"bytes,7,opt,name=database_create,json=databaseCreate,proto3,oneof"`
}

type Task_DatabaseUpdate_ struct {
	DatabaseUpdate *Task_DatabaseUpdate `protobuf:"bytes,8,opt,name=database_update,json=databaseUpdate,proto3,oneof"`
}

func (*Task_DatabaseCreate_) isTask_Payload() {}

func (*Task_DatabaseUpdate_) isTask_Payload() {}

type TaskRun struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Format: users/[email protected]
	Creator    string                 `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty"`
	CreateTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	UpdateTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
	// The current execution status of the task run.
	Status TaskRun_Status `protobuf:"varint,5,opt,name=status,proto3,enum=bytebase.v1.TaskRun_Status" json:"status,omitempty"`
	// Below are the results of a task run.
	// Detailed information about the task run result.
	Detail string `protobuf:"bytes,6,opt,name=detail,proto3" json:"detail,omitempty"`
	// The time when the task run started execution.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// Indicates whether a prior backup was created for this task run.
	// When true, rollback SQL can be generated via PreviewTaskRunRollback.
	// Backup details are available in the task run logs.
	HasPriorBackup bool `protobuf:"varint,11,opt,name=has_prior_backup,json=hasPriorBackup,proto3" json:"has_prior_backup,omitempty"`
	// Scheduling information about the task run.
	SchedulerInfo *TaskRun_SchedulerInfo `protobuf:"bytes,12,opt,name=scheduler_info,json=schedulerInfo,proto3" json:"scheduler_info,omitempty"`
	// The task run should run after run_time.
	// This can only be set when creating the task run calling BatchRunTasks.
	RunTime       *timestamppb.Timestamp `protobuf:"bytes,14,opt,name=run_time,json=runTime,proto3,oneof" json:"run_time,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRun) Reset() {
	*x = TaskRun{}
	mi := &file_v1_rollout_service_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRun) ProtoMessage() {}

func (x *TaskRun) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[17]
	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 TaskRun.ProtoReflect.Descriptor instead.
func (*TaskRun) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{17}
}

func (x *TaskRun) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *TaskRun) GetCreator() string {
	if x != nil {
		return x.Creator
	}
	return ""
}

func (x *TaskRun) GetCreateTime() *timestamppb.Timestamp {
	if x != nil {
		return x.CreateTime
	}
	return nil
}

func (x *TaskRun) GetUpdateTime() *timestamppb.Timestamp {
	if x != nil {
		return x.UpdateTime
	}
	return nil
}

func (x *TaskRun) GetStatus() TaskRun_Status {
	if x != nil {
		return x.Status
	}
	return TaskRun_STATUS_UNSPECIFIED
}

func (x *TaskRun) GetDetail() string {
	if x != nil {
		return x.Detail
	}
	return ""
}

func (x *TaskRun) GetStartTime() *timestamppb.Timestamp {
	if x != nil {
		return x.StartTime
	}
	return nil
}

func (x *TaskRun) GetHasPriorBackup() bool {
	if x != nil {
		return x.HasPriorBackup
	}
	return false
}

func (x *TaskRun) GetSchedulerInfo() *TaskRun_SchedulerInfo {
	if x != nil {
		return x.SchedulerInfo
	}
	return nil
}

func (x *TaskRun) GetRunTime() *timestamppb.Timestamp {
	if x != nil {
		return x.RunTime
	}
	return nil
}

type TaskRunLog struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}/log
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The log entries for this task run.
	Entries       []*TaskRunLogEntry `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLog) Reset() {
	*x = TaskRunLog{}
	mi := &file_v1_rollout_service_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLog) ProtoMessage() {}

func (x *TaskRunLog) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[18]
	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 TaskRunLog.ProtoReflect.Descriptor instead.
func (*TaskRunLog) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{18}
}

func (x *TaskRunLog) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *TaskRunLog) GetEntries() []*TaskRunLogEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

type TaskRunLogEntry struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The type of this log entry.
	Type TaskRunLogEntry_Type `protobuf:"varint,1,opt,name=type,proto3,enum=bytebase.v1.TaskRunLogEntry_Type" json:"type,omitempty"`
	// The time when the log was recorded.
	LogTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=log_time,json=logTime,proto3" json:"log_time,omitempty"`
	// The replica ID for this log entry.
	ReplicaId string `protobuf:"bytes,3,opt,name=replica_id,json=replicaId,proto3" json:"replica_id,omitempty"`
	// Schema dump details (if type is SCHEMA_DUMP).
	SchemaDump *TaskRunLogEntry_SchemaDump `protobuf:"bytes,4,opt,name=schema_dump,json=schemaDump,proto3" json:"schema_dump,omitempty"`
	// Command execution details (if type is COMMAND_EXECUTE).
	CommandExecute *TaskRunLogEntry_CommandExecute `protobuf:"bytes,5,opt,name=command_execute,json=commandExecute,proto3" json:"command_execute,omitempty"`
	// Database sync details (if type is DATABASE_SYNC).
	DatabaseSync *TaskRunLogEntry_DatabaseSync `protobuf:"bytes,6,opt,name=database_sync,json=databaseSync,proto3" json:"database_sync,omitempty"`
	// Transaction control details (if type is TRANSACTION_CONTROL).
	TransactionControl *TaskRunLogEntry_TransactionControl `protobuf:"bytes,8,opt,name=transaction_control,json=transactionControl,proto3" json:"transaction_control,omitempty"`
	// Prior backup details (if type is PRIOR_BACKUP).
	PriorBackup *TaskRunLogEntry_PriorBackup `protobuf:"bytes,9,opt,name=prior_backup,json=priorBackup,proto3" json:"prior_backup,omitempty"`
	// Retry information details (if type is RETRY_INFO).
	RetryInfo *TaskRunLogEntry_RetryInfo `protobuf:"bytes,10,opt,name=retry_info,json=retryInfo,proto3" json:"retry_info,omitempty"`
	// Compute diff details (if type is COMPUTE_DIFF).
	ComputeDiff *TaskRunLogEntry_ComputeDiff `protobuf:"bytes,11,opt,name=compute_diff,json=computeDiff,proto3" json:"compute_diff,omitempty"`
	// Release file execution details (if type is RELEASE_FILE_EXECUTE).
	ReleaseFileExecute *TaskRunLogEntry_ReleaseFileExecute `protobuf:"bytes,12,opt,name=release_file_execute,json=releaseFileExecute,proto3" json:"release_file_execute,omitempty"`
	// gh-ost migration details (if type is GHOST_MIGRATION).
	GhostMigration *TaskRunLogEntry_GhostMigration `protobuf:"bytes,13,opt,name=ghost_migration,json=ghostMigration,proto3" json:"ghost_migration,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *TaskRunLogEntry) Reset() {
	*x = TaskRunLogEntry{}
	mi := &file_v1_rollout_service_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry) ProtoMessage() {}

func (x *TaskRunLogEntry) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[19]
	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 TaskRunLogEntry.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19}
}

func (x *TaskRunLogEntry) GetType() TaskRunLogEntry_Type {
	if x != nil {
		return x.Type
	}
	return TaskRunLogEntry_TYPE_UNSPECIFIED
}

func (x *TaskRunLogEntry) GetLogTime() *timestamppb.Timestamp {
	if x != nil {
		return x.LogTime
	}
	return nil
}

func (x *TaskRunLogEntry) GetReplicaId() string {
	if x != nil {
		return x.ReplicaId
	}
	return ""
}

func (x *TaskRunLogEntry) GetSchemaDump() *TaskRunLogEntry_SchemaDump {
	if x != nil {
		return x.SchemaDump
	}
	return nil
}

func (x *TaskRunLogEntry) GetCommandExecute() *TaskRunLogEntry_CommandExecute {
	if x != nil {
		return x.CommandExecute
	}
	return nil
}

func (x *TaskRunLogEntry) GetDatabaseSync() *TaskRunLogEntry_DatabaseSync {
	if x != nil {
		return x.DatabaseSync
	}
	return nil
}

func (x *TaskRunLogEntry) GetTransactionControl() *TaskRunLogEntry_TransactionControl {
	if x != nil {
		return x.TransactionControl
	}
	return nil
}

func (x *TaskRunLogEntry) GetPriorBackup() *TaskRunLogEntry_PriorBackup {
	if x != nil {
		return x.PriorBackup
	}
	return nil
}

func (x *TaskRunLogEntry) GetRetryInfo() *TaskRunLogEntry_RetryInfo {
	if x != nil {
		return x.RetryInfo
	}
	return nil
}

func (x *TaskRunLogEntry) GetComputeDiff() *TaskRunLogEntry_ComputeDiff {
	if x != nil {
		return x.ComputeDiff
	}
	return nil
}

func (x *TaskRunLogEntry) GetReleaseFileExecute() *TaskRunLogEntry_ReleaseFileExecute {
	if x != nil {
		return x.ReleaseFileExecute
	}
	return nil
}

func (x *TaskRunLogEntry) GetGhostMigration() *TaskRunLogEntry_GhostMigration {
	if x != nil {
		return x.GhostMigration
	}
	return nil
}

type GetTaskRunSessionRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}
	Parent        string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetTaskRunSessionRequest) Reset() {
	*x = GetTaskRunSessionRequest{}
	mi := &file_v1_rollout_service_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetTaskRunSessionRequest) ProtoMessage() {}

func (x *GetTaskRunSessionRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[20]
	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 GetTaskRunSessionRequest.ProtoReflect.Descriptor instead.
func (*GetTaskRunSessionRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{20}
}

func (x *GetTaskRunSessionRequest) GetParent() string {
	if x != nil {
		return x.Parent
	}
	return ""
}

type TaskRunSession struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}/session
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Database-specific session information.
	//
	// Types that are valid to be assigned to Session:
	//
	//	*TaskRunSession_Postgres_
	Session       isTaskRunSession_Session `protobuf_oneof:"session"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunSession) Reset() {
	*x = TaskRunSession{}
	mi := &file_v1_rollout_service_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunSession) ProtoMessage() {}

func (x *TaskRunSession) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[21]
	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 TaskRunSession.ProtoReflect.Descriptor instead.
func (*TaskRunSession) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{21}
}

func (x *TaskRunSession) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *TaskRunSession) GetSession() isTaskRunSession_Session {
	if x != nil {
		return x.Session
	}
	return nil
}

func (x *TaskRunSession) GetPostgres() *TaskRunSession_Postgres {
	if x != nil {
		if x, ok := x.Session.(*TaskRunSession_Postgres_); ok {
			return x.Postgres
		}
	}
	return nil
}

type isTaskRunSession_Session interface {
	isTaskRunSession_Session()
}

type TaskRunSession_Postgres_ struct {
	// PostgreSQL session information.
	Postgres *TaskRunSession_Postgres `protobuf:"bytes,2,opt,name=postgres,proto3,oneof"`
}

func (*TaskRunSession_Postgres_) isTaskRunSession_Session() {}

type PreviewTaskRunRollbackRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}
	Name          string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PreviewTaskRunRollbackRequest) Reset() {
	*x = PreviewTaskRunRollbackRequest{}
	mi := &file_v1_rollout_service_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PreviewTaskRunRollbackRequest) ProtoMessage() {}

func (x *PreviewTaskRunRollbackRequest) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[22]
	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 PreviewTaskRunRollbackRequest.ProtoReflect.Descriptor instead.
func (*PreviewTaskRunRollbackRequest) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{22}
}

func (x *PreviewTaskRunRollbackRequest) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

type PreviewTaskRunRollbackResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The rollback SQL statement that would undo the task run.
	Statement     string `protobuf:"bytes,1,opt,name=statement,proto3" json:"statement,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PreviewTaskRunRollbackResponse) Reset() {
	*x = PreviewTaskRunRollbackResponse{}
	mi := &file_v1_rollout_service_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PreviewTaskRunRollbackResponse) ProtoMessage() {}

func (x *PreviewTaskRunRollbackResponse) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[23]
	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 PreviewTaskRunRollbackResponse.ProtoReflect.Descriptor instead.
func (*PreviewTaskRunRollbackResponse) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{23}
}

func (x *PreviewTaskRunRollbackResponse) GetStatement() string {
	if x != nil {
		return x.Statement
	}
	return ""
}

// Payload for creating a new database.
type Task_DatabaseCreate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Format: projects/{project}/sheets/{sheet}
	Sheet         string `protobuf:"bytes,4,opt,name=sheet,proto3" json:"sheet,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Task_DatabaseCreate) Reset() {
	*x = Task_DatabaseCreate{}
	mi := &file_v1_rollout_service_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Task_DatabaseCreate) ProtoMessage() {}

func (x *Task_DatabaseCreate) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[24]
	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 Task_DatabaseCreate.ProtoReflect.Descriptor instead.
func (*Task_DatabaseCreate) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{16, 0}
}

func (x *Task_DatabaseCreate) GetSheet() string {
	if x != nil {
		return x.Sheet
	}
	return ""
}

// Payload for updating a database schema.
type Task_DatabaseUpdate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The source can be either a sheet or a release.
	//
	// Types that are valid to be assigned to Source:
	//
	//	*Task_DatabaseUpdate_Sheet
	//	*Task_DatabaseUpdate_Release
	Source        isTask_DatabaseUpdate_Source `protobuf_oneof:"source"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Task_DatabaseUpdate) Reset() {
	*x = Task_DatabaseUpdate{}
	mi := &file_v1_rollout_service_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Task_DatabaseUpdate) ProtoMessage() {}

func (x *Task_DatabaseUpdate) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[25]
	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 Task_DatabaseUpdate.ProtoReflect.Descriptor instead.
func (*Task_DatabaseUpdate) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{16, 1}
}

func (x *Task_DatabaseUpdate) GetSource() isTask_DatabaseUpdate_Source {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *Task_DatabaseUpdate) GetSheet() string {
	if x != nil {
		if x, ok := x.Source.(*Task_DatabaseUpdate_Sheet); ok {
			return x.Sheet
		}
	}
	return ""
}

func (x *Task_DatabaseUpdate) GetRelease() string {
	if x != nil {
		if x, ok := x.Source.(*Task_DatabaseUpdate_Release); ok {
			return x.Release
		}
	}
	return ""
}

type isTask_DatabaseUpdate_Source interface {
	isTask_DatabaseUpdate_Source()
}

type Task_DatabaseUpdate_Sheet struct {
	// Format: projects/{project}/sheets/{sheet}
	Sheet string `protobuf:"bytes,1,opt,name=sheet,proto3,oneof"`
}

type Task_DatabaseUpdate_Release struct {
	// Format: projects/{project}/releases/{release}
	Release string `protobuf:"bytes,4,opt,name=release,proto3,oneof"`
}

func (*Task_DatabaseUpdate_Sheet) isTask_DatabaseUpdate_Source() {}

func (*Task_DatabaseUpdate_Release) isTask_DatabaseUpdate_Source() {}

// Information about task run scheduling.
type TaskRun_SchedulerInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The time when the scheduling info was reported.
	ReportTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=report_time,json=reportTime,proto3" json:"report_time,omitempty"`
	// The cause for the task run waiting.
	WaitingCause  *TaskRun_SchedulerInfo_WaitingCause `protobuf:"bytes,2,opt,name=waiting_cause,json=waitingCause,proto3" json:"waiting_cause,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRun_SchedulerInfo) Reset() {
	*x = TaskRun_SchedulerInfo{}
	mi := &file_v1_rollout_service_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRun_SchedulerInfo) ProtoMessage() {}

func (x *TaskRun_SchedulerInfo) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[26]
	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 TaskRun_SchedulerInfo.ProtoReflect.Descriptor instead.
func (*TaskRun_SchedulerInfo) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{17, 0}
}

func (x *TaskRun_SchedulerInfo) GetReportTime() *timestamppb.Timestamp {
	if x != nil {
		return x.ReportTime
	}
	return nil
}

func (x *TaskRun_SchedulerInfo) GetWaitingCause() *TaskRun_SchedulerInfo_WaitingCause {
	if x != nil {
		return x.WaitingCause
	}
	return nil
}

// Information about why a task run is waiting.
type TaskRun_SchedulerInfo_WaitingCause struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The reason the task run is waiting.
	//
	// Types that are valid to be assigned to Cause:
	//
	//	*TaskRun_SchedulerInfo_WaitingCause_ParallelTasksLimit
	Cause         isTaskRun_SchedulerInfo_WaitingCause_Cause `protobuf_oneof:"cause"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRun_SchedulerInfo_WaitingCause) Reset() {
	*x = TaskRun_SchedulerInfo_WaitingCause{}
	mi := &file_v1_rollout_service_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRun_SchedulerInfo_WaitingCause) ProtoMessage() {}

func (x *TaskRun_SchedulerInfo_WaitingCause) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[27]
	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 TaskRun_SchedulerInfo_WaitingCause.ProtoReflect.Descriptor instead.
func (*TaskRun_SchedulerInfo_WaitingCause) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{17, 0, 0}
}

func (x *TaskRun_SchedulerInfo_WaitingCause) GetCause() isTaskRun_SchedulerInfo_WaitingCause_Cause {
	if x != nil {
		return x.Cause
	}
	return nil
}

func (x *TaskRun_SchedulerInfo_WaitingCause) GetParallelTasksLimit() bool {
	if x != nil {
		if x, ok := x.Cause.(*TaskRun_SchedulerInfo_WaitingCause_ParallelTasksLimit); ok {
			return x.ParallelTasksLimit
		}
	}
	return false
}

type isTaskRun_SchedulerInfo_WaitingCause_Cause interface {
	isTaskRun_SchedulerInfo_WaitingCause_Cause()
}

type TaskRun_SchedulerInfo_WaitingCause_ParallelTasksLimit struct {
	// Waiting due to parallel tasks limit.
	ParallelTasksLimit bool `protobuf:"varint,3,opt,name=parallel_tasks_limit,json=parallelTasksLimit,proto3,oneof"`
}

func (*TaskRun_SchedulerInfo_WaitingCause_ParallelTasksLimit) isTaskRun_SchedulerInfo_WaitingCause_Cause() {
}

// Schema dump operation details.
type TaskRunLogEntry_SchemaDump struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// When the schema dump started.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// When the schema dump ended.
	EndTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// Error message if the schema dump failed.
	Error         string `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_SchemaDump) Reset() {
	*x = TaskRunLogEntry_SchemaDump{}
	mi := &file_v1_rollout_service_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_SchemaDump) ProtoMessage() {}

func (x *TaskRunLogEntry_SchemaDump) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[28]
	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 TaskRunLogEntry_SchemaDump.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_SchemaDump) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 0}
}

func (x *TaskRunLogEntry_SchemaDump) GetStartTime() *timestamppb.Timestamp {
	if x != nil {
		return x.StartTime
	}
	return nil
}

func (x *TaskRunLogEntry_SchemaDump) GetEndTime() *timestamppb.Timestamp {
	if x != nil {
		return x.EndTime
	}
	return nil
}

func (x *TaskRunLogEntry_SchemaDump) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

// Command execution details.
type TaskRunLogEntry_CommandExecute struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// When the command was logged.
	LogTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=log_time,json=logTime,proto3" json:"log_time,omitempty"`
	// The byte offset range of the executed command in the sheet.
	// Uses byte offsets (not character indices) for efficient slicing of sheet content bytes.
	// Example: For "SELECT 你好;" in a UTF-8 sheet, range [0, 13) represents all 13 bytes.
	Range *Range `protobuf:"bytes,2,opt,name=range,proto3" json:"range,omitempty"`
	// The executed statement.
	Statement string `protobuf:"bytes,4,opt,name=statement,proto3" json:"statement,omitempty"`
	// The response from executing the command.
	Response      *TaskRunLogEntry_CommandExecute_CommandResponse `protobuf:"bytes,3,opt,name=response,proto3" json:"response,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_CommandExecute) Reset() {
	*x = TaskRunLogEntry_CommandExecute{}
	mi := &file_v1_rollout_service_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_CommandExecute) ProtoMessage() {}

func (x *TaskRunLogEntry_CommandExecute) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[29]
	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 TaskRunLogEntry_CommandExecute.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_CommandExecute) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 1}
}

func (x *TaskRunLogEntry_CommandExecute) GetLogTime() *timestamppb.Timestamp {
	if x != nil {
		return x.LogTime
	}
	return nil
}

func (x *TaskRunLogEntry_CommandExecute) GetRange() *Range {
	if x != nil {
		return x.Range
	}
	return nil
}

func (x *TaskRunLogEntry_CommandExecute) GetStatement() string {
	if x != nil {
		return x.Statement
	}
	return ""
}

func (x *TaskRunLogEntry_CommandExecute) GetResponse() *TaskRunLogEntry_CommandExecute_CommandResponse {
	if x != nil {
		return x.Response
	}
	return nil
}

// Database synchronization details.
type TaskRunLogEntry_DatabaseSync struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// When the database sync started.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// When the database sync ended.
	EndTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// Error message if sync failed.
	Error         string `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_DatabaseSync) Reset() {
	*x = TaskRunLogEntry_DatabaseSync{}
	mi := &file_v1_rollout_service_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_DatabaseSync) ProtoMessage() {}

func (x *TaskRunLogEntry_DatabaseSync) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[30]
	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 TaskRunLogEntry_DatabaseSync.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_DatabaseSync) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 2}
}

func (x *TaskRunLogEntry_DatabaseSync) GetStartTime() *timestamppb.Timestamp {
	if x != nil {
		return x.StartTime
	}
	return nil
}

func (x *TaskRunLogEntry_DatabaseSync) GetEndTime() *timestamppb.Timestamp {
	if x != nil {
		return x.EndTime
	}
	return nil
}

func (x *TaskRunLogEntry_DatabaseSync) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

// Transaction control operation details.
type TaskRunLogEntry_TransactionControl struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The type of transaction control.
	Type TaskRunLogEntry_TransactionControl_Type `protobuf:"varint,1,opt,name=type,proto3,enum=bytebase.v1.TaskRunLogEntry_TransactionControl_Type" json:"type,omitempty"`
	// Error message if the operation failed.
	Error         string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_TransactionControl) Reset() {
	*x = TaskRunLogEntry_TransactionControl{}
	mi := &file_v1_rollout_service_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_TransactionControl) ProtoMessage() {}

func (x *TaskRunLogEntry_TransactionControl) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[31]
	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 TaskRunLogEntry_TransactionControl.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_TransactionControl) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 3}
}

func (x *TaskRunLogEntry_TransactionControl) GetType() TaskRunLogEntry_TransactionControl_Type {
	if x != nil {
		return x.Type
	}
	return TaskRunLogEntry_TransactionControl_TYPE_UNSPECIFIED
}

func (x *TaskRunLogEntry_TransactionControl) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

// Prior backup operation details.
type TaskRunLogEntry_PriorBackup struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// When the backup started.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// When the backup ended.
	EndTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// The backup details.
	PriorBackupDetail *TaskRunLogEntry_PriorBackup_PriorBackupDetail `protobuf:"bytes,3,opt,name=prior_backup_detail,json=priorBackupDetail,proto3" json:"prior_backup_detail,omitempty"`
	// Error message if the backup failed.
	Error         string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_PriorBackup) Reset() {
	*x = TaskRunLogEntry_PriorBackup{}
	mi := &file_v1_rollout_service_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_PriorBackup) ProtoMessage() {}

func (x *TaskRunLogEntry_PriorBackup) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[32]
	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 TaskRunLogEntry_PriorBackup.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_PriorBackup) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 4}
}

func (x *TaskRunLogEntry_PriorBackup) GetStartTime() *timestamppb.Timestamp {
	if x != nil {
		return x.StartTime
	}
	return nil
}

func (x *TaskRunLogEntry_PriorBackup) GetEndTime() *timestamppb.Timestamp {
	if x != nil {
		return x.EndTime
	}
	return nil
}

func (x *TaskRunLogEntry_PriorBackup) GetPriorBackupDetail() *TaskRunLogEntry_PriorBackup_PriorBackupDetail {
	if x != nil {
		return x.PriorBackupDetail
	}
	return nil
}

func (x *TaskRunLogEntry_PriorBackup) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

// Retry information for failed operations.
type TaskRunLogEntry_RetryInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The error that triggered the retry.
	Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	// Current retry attempt number.
	RetryCount int32 `protobuf:"varint,2,opt,name=retry_count,json=retryCount,proto3" json:"retry_count,omitempty"`
	// Maximum number of retries allowed.
	MaximumRetries int32 `protobuf:"varint,3,opt,name=maximum_retries,json=maximumRetries,proto3" json:"maximum_retries,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *TaskRunLogEntry_RetryInfo) Reset() {
	*x = TaskRunLogEntry_RetryInfo{}
	mi := &file_v1_rollout_service_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_RetryInfo) ProtoMessage() {}

func (x *TaskRunLogEntry_RetryInfo) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[33]
	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 TaskRunLogEntry_RetryInfo.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_RetryInfo) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 5}
}

func (x *TaskRunLogEntry_RetryInfo) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

func (x *TaskRunLogEntry_RetryInfo) GetRetryCount() int32 {
	if x != nil {
		return x.RetryCount
	}
	return 0
}

func (x *TaskRunLogEntry_RetryInfo) GetMaximumRetries() int32 {
	if x != nil {
		return x.MaximumRetries
	}
	return 0
}

// Schema diff computation details.
type TaskRunLogEntry_ComputeDiff struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// When diff computation started.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// When diff computation ended.
	EndTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// Error message if computation failed.
	Error         string `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_ComputeDiff) Reset() {
	*x = TaskRunLogEntry_ComputeDiff{}
	mi := &file_v1_rollout_service_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_ComputeDiff) ProtoMessage() {}

func (x *TaskRunLogEntry_ComputeDiff) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[34]
	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 TaskRunLogEntry_ComputeDiff.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_ComputeDiff) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 6}
}

func (x *TaskRunLogEntry_ComputeDiff) GetStartTime() *timestamppb.Timestamp {
	if x != nil {
		return x.StartTime
	}
	return nil
}

func (x *TaskRunLogEntry_ComputeDiff) GetEndTime() *timestamppb.Timestamp {
	if x != nil {
		return x.EndTime
	}
	return nil
}

func (x *TaskRunLogEntry_ComputeDiff) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

// gh-ost migration details.
type TaskRunLogEntry_GhostMigration struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// When the gh-ost migration started.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// When the gh-ost migration ended.
	EndTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// Error message if the gh-ost migration failed.
	Error         string `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_GhostMigration) Reset() {
	*x = TaskRunLogEntry_GhostMigration{}
	mi := &file_v1_rollout_service_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_GhostMigration) ProtoMessage() {}

func (x *TaskRunLogEntry_GhostMigration) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[35]
	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 TaskRunLogEntry_GhostMigration.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_GhostMigration) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 7}
}

func (x *TaskRunLogEntry_GhostMigration) GetStartTime() *timestamppb.Timestamp {
	if x != nil {
		return x.StartTime
	}
	return nil
}

func (x *TaskRunLogEntry_GhostMigration) GetEndTime() *timestamppb.Timestamp {
	if x != nil {
		return x.EndTime
	}
	return nil
}

func (x *TaskRunLogEntry_GhostMigration) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

// Release file execution details.
type TaskRunLogEntry_ReleaseFileExecute struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The version of the file being executed (e.g., "0001").
	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// The file path within the release (e.g., "2.2/V0001_create_table.sql").
	FilePath      string `protobuf:"bytes,2,opt,name=file_path,json=filePath,proto3" json:"file_path,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_ReleaseFileExecute) Reset() {
	*x = TaskRunLogEntry_ReleaseFileExecute{}
	mi := &file_v1_rollout_service_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_ReleaseFileExecute) ProtoMessage() {}

func (x *TaskRunLogEntry_ReleaseFileExecute) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[36]
	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 TaskRunLogEntry_ReleaseFileExecute.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_ReleaseFileExecute) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 8}
}

func (x *TaskRunLogEntry_ReleaseFileExecute) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

func (x *TaskRunLogEntry_ReleaseFileExecute) GetFilePath() string {
	if x != nil {
		return x.FilePath
	}
	return ""
}

// Command execution response.
type TaskRunLogEntry_CommandExecute_CommandResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// When the response was logged.
	LogTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=log_time,json=logTime,proto3" json:"log_time,omitempty"`
	// Error message if command execution failed.
	Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	// Total affected rows.
	AffectedRows int64 `protobuf:"varint,3,opt,name=affected_rows,json=affectedRows,proto3" json:"affected_rows,omitempty"`
	// `all_affected_rows` is the affected rows of each command.
	// `all_affected_rows` may be unavailable if the database driver doesn't support it. Caller should fallback to `affected_rows` in that case.
	AllAffectedRows []int64 `protobuf:"varint,4,rep,packed,name=all_affected_rows,json=allAffectedRows,proto3" json:"all_affected_rows,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *TaskRunLogEntry_CommandExecute_CommandResponse) Reset() {
	*x = TaskRunLogEntry_CommandExecute_CommandResponse{}
	mi := &file_v1_rollout_service_proto_msgTypes[37]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_CommandExecute_CommandResponse) ProtoMessage() {}

func (x *TaskRunLogEntry_CommandExecute_CommandResponse) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[37]
	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 TaskRunLogEntry_CommandExecute_CommandResponse.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_CommandExecute_CommandResponse) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 1, 0}
}

func (x *TaskRunLogEntry_CommandExecute_CommandResponse) GetLogTime() *timestamppb.Timestamp {
	if x != nil {
		return x.LogTime
	}
	return nil
}

func (x *TaskRunLogEntry_CommandExecute_CommandResponse) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

func (x *TaskRunLogEntry_CommandExecute_CommandResponse) GetAffectedRows() int64 {
	if x != nil {
		return x.AffectedRows
	}
	return 0
}

func (x *TaskRunLogEntry_CommandExecute_CommandResponse) GetAllAffectedRows() []int64 {
	if x != nil {
		return x.AllAffectedRows
	}
	return nil
}

// Prior backup detail for rollback purposes.
type TaskRunLogEntry_PriorBackup_PriorBackupDetail struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The list of backed up tables.
	Items         []*TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail) Reset() {
	*x = TaskRunLogEntry_PriorBackup_PriorBackupDetail{}
	mi := &file_v1_rollout_service_proto_msgTypes[38]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_PriorBackup_PriorBackupDetail) ProtoMessage() {}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[38]
	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 TaskRunLogEntry_PriorBackup_PriorBackupDetail.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_PriorBackup_PriorBackupDetail) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 4, 0}
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail) GetItems() []*TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item {
	if x != nil {
		return x.Items
	}
	return nil
}

// A single backup table mapping.
type TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The original table information.
	SourceTable *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table `protobuf:"bytes,1,opt,name=source_table,json=sourceTable,proto3" json:"source_table,omitempty"`
	// The target backup table information.
	TargetTable *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table `protobuf:"bytes,2,opt,name=target_table,json=targetTable,proto3" json:"target_table,omitempty"`
	// The start position in the SQL statement.
	StartPosition *Position `protobuf:"bytes,3,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"`
	// The end position in the SQL statement.
	EndPosition   *Position `protobuf:"bytes,4,opt,name=end_position,json=endPosition,proto3" json:"end_position,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item) Reset() {
	*x = TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item{}
	mi := &file_v1_rollout_service_proto_msgTypes[39]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item) ProtoMessage() {}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[39]
	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 TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 4, 0, 0}
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item) GetSourceTable() *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table {
	if x != nil {
		return x.SourceTable
	}
	return nil
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item) GetTargetTable() *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table {
	if x != nil {
		return x.TargetTable
	}
	return nil
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item) GetStartPosition() *Position {
	if x != nil {
		return x.StartPosition
	}
	return nil
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item) GetEndPosition() *Position {
	if x != nil {
		return x.EndPosition
	}
	return nil
}

// Table information.
type TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The database information.
	// Format: instances/{instance}/databases/{database} or projects/{project}/instances/{instance}/databases/{database}
	Database string `protobuf:"bytes,1,opt,name=database,proto3" json:"database,omitempty"`
	// The schema name.
	Schema string `protobuf:"bytes,2,opt,name=schema,proto3" json:"schema,omitempty"`
	// The table name.
	Table         string `protobuf:"bytes,3,opt,name=table,proto3" json:"table,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table) Reset() {
	*x = TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table{}
	mi := &file_v1_rollout_service_proto_msgTypes[40]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table) ProtoMessage() {}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[40]
	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 TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table.ProtoReflect.Descriptor instead.
func (*TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{19, 4, 0, 0, 0}
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table) GetDatabase() string {
	if x != nil {
		return x.Database
	}
	return ""
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table) GetSchema() string {
	if x != nil {
		return x.Schema
	}
	return ""
}

func (x *TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table) GetTable() string {
	if x != nil {
		return x.Table
	}
	return ""
}

// PostgreSQL session information.
type TaskRunSession_Postgres struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// `session` is the session of the task run executing commands.
	Session *TaskRunSession_Postgres_Session `protobuf:"bytes,1,opt,name=session,proto3" json:"session,omitempty"`
	// `blocking_sessions` block `session`.
	BlockingSessions []*TaskRunSession_Postgres_Session `protobuf:"bytes,2,rep,name=blocking_sessions,json=blockingSessions,proto3" json:"blocking_sessions,omitempty"`
	// `blocked_sessions` are blocked by `session`.
	BlockedSessions []*TaskRunSession_Postgres_Session `protobuf:"bytes,3,rep,name=blocked_sessions,json=blockedSessions,proto3" json:"blocked_sessions,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *TaskRunSession_Postgres) Reset() {
	*x = TaskRunSession_Postgres{}
	mi := &file_v1_rollout_service_proto_msgTypes[41]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunSession_Postgres) ProtoMessage() {}

func (x *TaskRunSession_Postgres) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[41]
	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 TaskRunSession_Postgres.ProtoReflect.Descriptor instead.
func (*TaskRunSession_Postgres) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{21, 0}
}

func (x *TaskRunSession_Postgres) GetSession() *TaskRunSession_Postgres_Session {
	if x != nil {
		return x.Session
	}
	return nil
}

func (x *TaskRunSession_Postgres) GetBlockingSessions() []*TaskRunSession_Postgres_Session {
	if x != nil {
		return x.BlockingSessions
	}
	return nil
}

func (x *TaskRunSession_Postgres) GetBlockedSessions() []*TaskRunSession_Postgres_Session {
	if x != nil {
		return x.BlockedSessions
	}
	return nil
}

// PostgreSQL session information read from `pg_stat_activity`.
type TaskRunSession_Postgres_Session struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Process ID of the session.
	Pid string `protobuf:"bytes,1,opt,name=pid,proto3" json:"pid,omitempty"`
	// PIDs of sessions blocking this session.
	BlockedByPids []string `protobuf:"bytes,2,rep,name=blocked_by_pids,json=blockedByPids,proto3" json:"blocked_by_pids,omitempty"`
	// Current query being executed.
	Query string `protobuf:"bytes,3,opt,name=query,proto3" json:"query,omitempty"`
	// Session state (active, idle, etc.).
	State *string `protobuf:"bytes,4,opt,name=state,proto3,oneof" json:"state,omitempty"`
	// Wait event type if session is waiting.
	WaitEventType *string `protobuf:"bytes,5,opt,name=wait_event_type,json=waitEventType,proto3,oneof" json:"wait_event_type,omitempty"`
	// Specific wait event if session is waiting.
	WaitEvent *string `protobuf:"bytes,6,opt,name=wait_event,json=waitEvent,proto3,oneof" json:"wait_event,omitempty"`
	// Database name.
	Datname *string `protobuf:"bytes,7,opt,name=datname,proto3,oneof" json:"datname,omitempty"`
	// User name.
	Usename *string `protobuf:"bytes,8,opt,name=usename,proto3,oneof" json:"usename,omitempty"`
	// Application name.
	ApplicationName string `protobuf:"bytes,9,opt,name=application_name,json=applicationName,proto3" json:"application_name,omitempty"`
	// Client IP address.
	ClientAddr *string `protobuf:"bytes,10,opt,name=client_addr,json=clientAddr,proto3,oneof" json:"client_addr,omitempty"`
	// Client port number.
	ClientPort *string `protobuf:"bytes,11,opt,name=client_port,json=clientPort,proto3,oneof" json:"client_port,omitempty"`
	// When the backend process started.
	BackendStart *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=backend_start,json=backendStart,proto3" json:"backend_start,omitempty"`
	// When the current transaction started.
	XactStart *timestamppb.Timestamp `protobuf:"bytes,13,opt,name=xact_start,json=xactStart,proto3,oneof" json:"xact_start,omitempty"`
	// When the current query started.
	QueryStart    *timestamppb.Timestamp `protobuf:"bytes,14,opt,name=query_start,json=queryStart,proto3,oneof" json:"query_start,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TaskRunSession_Postgres_Session) Reset() {
	*x = TaskRunSession_Postgres_Session{}
	mi := &file_v1_rollout_service_proto_msgTypes[42]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TaskRunSession_Postgres_Session) ProtoMessage() {}

func (x *TaskRunSession_Postgres_Session) ProtoReflect() protoreflect.Message {
	mi := &file_v1_rollout_service_proto_msgTypes[42]
	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 TaskRunSession_Postgres_Session.ProtoReflect.Descriptor instead.
func (*TaskRunSession_Postgres_Session) Descriptor() ([]byte, []int) {
	return file_v1_rollout_service_proto_rawDescGZIP(), []int{21, 0, 0}
}

func (x *TaskRunSession_Postgres_Session) GetPid() string {
	if x != nil {
		return x.Pid
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetBlockedByPids() []string {
	if x != nil {
		return x.BlockedByPids
	}
	return nil
}

func (x *TaskRunSession_Postgres_Session) GetQuery() string {
	if x != nil {
		return x.Query
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetState() string {
	if x != nil && x.State != nil {
		return *x.State
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetWaitEventType() string {
	if x != nil && x.WaitEventType != nil {
		return *x.WaitEventType
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetWaitEvent() string {
	if x != nil && x.WaitEvent != nil {
		return *x.WaitEvent
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetDatname() string {
	if x != nil && x.Datname != nil {
		return *x.Datname
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetUsename() string {
	if x != nil && x.Usename != nil {
		return *x.Usename
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetApplicationName() string {
	if x != nil {
		return x.ApplicationName
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetClientAddr() string {
	if x != nil && x.ClientAddr != nil {
		return *x.ClientAddr
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetClientPort() string {
	if x != nil && x.ClientPort != nil {
		return *x.ClientPort
	}
	return ""
}

func (x *TaskRunSession_Postgres_Session) GetBackendStart() *timestamppb.Timestamp {
	if x != nil {
		return x.BackendStart
	}
	return nil
}

func (x *TaskRunSession_Postgres_Session) GetXactStart() *timestamppb.Timestamp {
	if x != nil {
		return x.XactStart
	}
	return nil
}

func (x *TaskRunSession_Postgres_Session) GetQueryStart() *timestamppb.Timestamp {
	if x != nil {
		return x.QueryStart
	}
	return nil
}

var File_v1_rollout_service_proto protoreflect.FileDescriptor

const file_v1_rollout_service_proto_rawDesc = "" +
	"\n" +
	"\x18v1/rollout_service.proto\x12\vbytebase.v1\x1a\x1bbuf/validate/validate.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/api/field_behavior.proto\x1a\x19google/api/resource.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x13v1/annotation.proto\x1a\x0fv1/common.proto\"\xd5\x01\n" +
	"\x14BatchRunTasksRequest\x122\n" +
	"\x06parent\x18\x01 \x01(\tB\x1a\xe0A\x02\xfaA\x14\n" +
	"\x12bytebase.com/StageR\x06parent\x12\x14\n" +
	"\x05tasks\x18\x02 \x03(\tR\x05tasks\x12:\n" +
	"\brun_time\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampH\x00R\arunTime\x88\x01\x01\x12*\n" +
	"\x11skip_prior_backup\x18\x04 \x01(\bR\x0fskipPriorBackupB\v\n" +
	"\t_run_time\"\x17\n" +
	"\x15BatchRunTasksResponse\"\x83\x01\n" +
	"\x15BatchSkipTasksRequest\x122\n" +
	"\x06parent\x18\x01 \x01(\tB\x1a\xe0A\x02\xfaA\x14\n" +
	"\x12bytebase.com/StageR\x06parent\x12\x14\n" +
	"\x05tasks\x18\x02 \x03(\tR\x05tasks\x12 \n" +
	"\x06reason\x18\x03 \x01(\tB\b\xbaH\x05r\x03\x18\xe8\aR\x06reason\"\x18\n" +
	"\x16BatchSkipTasksResponse\"l\n" +
	"\x1aBatchCancelTaskRunsRequest\x121\n" +
	"\x06parent\x18\x01 \x01(\tB\x19\xe0A\x02\xfaA\x13\n" +
	"\x11bytebase.com/TaskR\x06parent\x12\x1b\n" +
	"\ttask_runs\x18\x02 \x03(\tR\btaskRuns\"\x1d\n" +
	"\x1bBatchCancelTaskRunsResponse\"E\n" +
	"\x11GetRolloutRequest\x120\n" +
	"\x04name\x18\x01 \x01(\tB\x1c\xe0A\x02\xfaA\x16\n" +
	"\x14bytebase.com/RolloutR\x04name\"\x9f\x01\n" +
	"\x13ListRolloutsRequest\x124\n" +
	"\x06parent\x18\x01 \x01(\tB\x1c\xe0A\x02\xfaA\x16\n" +
	"\x14bytebase.com/ProjectR\x06parent\x12\x1b\n" +
	"\tpage_size\x18\x02 \x01(\x05R\bpageSize\x12\x1d\n" +
	"\n" +
	"page_token\x18\x03 \x01(\tR\tpageToken\x12\x16\n" +
	"\x06filter\x18\x04 \x01(\tR\x06filter\"p\n" +
	"\x14ListRolloutsResponse\x120\n" +
	"\brollouts\x18\x01 \x03(\v2\x14.bytebase.v1.RolloutR\brollouts\x12&\n" +
	"\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"w\n" +
	"\x14CreateRolloutRequest\x121\n" +
	"\x06parent\x18\x01 \x01(\tB\x19\xe0A\x02\xfaA\x13\n" +
	"\x11bytebase.com/PlanR\x06parent\x12\x1b\n" +
	"\x06target\x18\x03 \x01(\tH\x00R\x06target\x88\x01\x01B\t\n" +
	"\a_targetJ\x04\b\x02\x10\x03\"\x84\x01\n" +
	"\x13ListTaskRunsRequest\x121\n" +
	"\x06parent\x18\x01 \x01(\tB\x19\xe0A\x02\xfaA\x13\n" +
	"\x11bytebase.com/TaskR\x06parent\x12\x1b\n" +
	"\tpage_size\x18\x02 \x01(\x05R\bpageSize\x12\x1d\n" +
	"\n" +
	"page_token\x18\x03 \x01(\tR\tpageToken\"q\n" +
	"\x14ListTaskRunsResponse\x121\n" +
	"\ttask_runs\x18\x01 \x03(\v2\x14.bytebase.v1.TaskRunR\btaskRuns\x12&\n" +
	"\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"E\n" +
	"\x11GetTaskRunRequest\x120\n" +
	"\x04name\x18\x01 \x01(\tB\x1c\xe0A\x02\xfaA\x16\n" +
	"\x14bytebase.com/TaskRunR\x04name\"L\n" +
	"\x14GetTaskRunLogRequest\x124\n" +
	"\x06parent\x18\x01 \x01(\tB\x1c\xe0A\x02\xfaA\x16\n" +
	"\x14bytebase.com/TaskRunR\x06parent\"\xbd\x02\n" +
	"\aRollout\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x19\n" +
	"\x05title\x18\x03 \x01(\tB\x03\xe0A\x03R\x05title\x12/\n" +
	"\x06stages\x18\x04 \x03(\v2\x12.bytebase.v1.StageB\x03\xe0A\x03R\x06stages\x12@\n" +
	"\vcreate_time\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03R\n" +
	"createTime\x12@\n" +
	"\vupdate_time\x18\a \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03R\n" +
	"updateTime:B\xeaA?\n" +
	"\x14bytebase.com/Rollout\x12'projects/{project}/plans/{plan}/rolloutJ\x04\b\x02\x10\x03J\x04\b\x05\x10\x06\"\xcc\x01\n" +
	"\x05Stage\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x13\n" +
	"\x02id\x18\x02 \x01(\tB\x03\xe0A\x03R\x02id\x12 \n" +
	"\venvironment\x18\x03 \x01(\tR\venvironment\x12'\n" +
	"\x05tasks\x18\x04 \x03(\v2\x11.bytebase.v1.TaskR\x05tasks:O\xeaAL\n" +
	"\x12bytebase.com/Stage\x126projects/{project}/plans/{plan}/rollout/stages/{stage}\"\xd5\a\n" +
	"\x04Task\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x17\n" +
	"\aspec_id\x18\x02 \x01(\tR\x06specId\x120\n" +
	"\x06status\x18\x03 \x01(\x0e2\x18.bytebase.v1.Task.StatusR\x06status\x12%\n" +
	"\x0eskipped_reason\x18\x04 \x01(\tR\rskippedReason\x12*\n" +
	"\x04type\x18\x05 \x01(\x0e2\x16.bytebase.v1.Task.TypeR\x04type\x12\x16\n" +
	"\x06target\x18\x06 \x01(\tR\x06target\x12K\n" +
	"\x0fdatabase_create\x18\a \x01(\v2 .bytebase.v1.Task.DatabaseCreateH\x00R\x0edatabaseCreate\x12K\n" +
	"\x0fdatabase_update\x18\b \x01(\v2 .bytebase.v1.Task.DatabaseUpdateH\x00R\x0edatabaseUpdate\x12E\n" +
	"\vupdate_time\x18\n" +
	" \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03H\x01R\n" +
	"updateTime\x88\x01\x01\x12?\n" +
	"\brun_time\x18\v \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03H\x02R\arunTime\x88\x01\x01\x1a,\n" +
	"\x0eDatabaseCreate\x12\x14\n" +
	"\x05sheet\x18\x04 \x01(\tR\x05sheetJ\x04\b\x01\x10\x04\x1aT\n" +
	"\x0eDatabaseUpdate\x12\x16\n" +
	"\x05sheet\x18\x01 \x01(\tH\x00R\x05sheet\x12\x1a\n" +
	"\arelease\x18\x04 \x01(\tH\x00R\areleaseB\b\n" +
	"\x06sourceJ\x04\b\x02\x10\x04\"|\n" +
	"\x06Status\x12\x16\n" +
	"\x12STATUS_UNSPECIFIED\x10\x00\x12\x0f\n" +
	"\vNOT_STARTED\x10\x01\x12\v\n" +
	"\aPENDING\x10\x02\x12\v\n" +
	"\aRUNNING\x10\x03\x12\b\n" +
	"\x04DONE\x10\x04\x12\n" +
	"\n" +
	"\x06FAILED\x10\x05\x12\f\n" +
	"\bCANCELED\x10\x06\x12\v\n" +
	"\aSKIPPED\x10\a\"T\n" +
	"\x04Type\x12\x14\n" +
	"\x10TYPE_UNSPECIFIED\x10\x00\x12\v\n" +
	"\aGENERAL\x10\x01\x12\x13\n" +
	"\x0fDATABASE_CREATE\x10\x02\x12\x14\n" +
	"\x10DATABASE_MIGRATE\x10\x03:[\xeaAX\n" +
	"\x11bytebase.com/Task\x12Cprojects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}B\t\n" +
	"\apayloadB\x0e\n" +
	"\f_update_timeB\v\n" +
	"\t_run_timeJ\x04\b\t\x10\n" +
	"\"\xfc\a\n" +
	"\aTaskRun\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" +
	"\acreator\x18\x02 \x01(\tR\acreator\x12@\n" +
	"\vcreate_time\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03R\n" +
	"createTime\x12@\n" +
	"\vupdate_time\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03R\n" +
	"updateTime\x123\n" +
	"\x06status\x18\x05 \x01(\x0e2\x1b.bytebase.v1.TaskRun.StatusR\x06status\x12\x16\n" +
	"\x06detail\x18\x06 \x01(\tR\x06detail\x12>\n" +
	"\n" +
	"start_time\x18\t \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03R\tstartTime\x12(\n" +
	"\x10has_prior_backup\x18\v \x01(\bR\x0ehasPriorBackup\x12N\n" +
	"\x0escheduler_info\x18\f \x01(\v2\".bytebase.v1.TaskRun.SchedulerInfoB\x03\xe0A\x03R\rschedulerInfo\x12?\n" +
	"\brun_time\x18\x0e \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03H\x00R\arunTime\x88\x01\x01\x1a\xf5\x01\n" +
	"\rSchedulerInfo\x12;\n" +
	"\vreport_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"reportTime\x12T\n" +
	"\rwaiting_cause\x18\x02 \x01(\v2/.bytebase.v1.TaskRun.SchedulerInfo.WaitingCauseR\fwaitingCause\x1aQ\n" +
	"\fWaitingCause\x122\n" +
	"\x14parallel_tasks_limit\x18\x03 \x01(\bH\x00R\x12parallelTasksLimitB\a\n" +
	"\x05causeJ\x04\b\x01\x10\x03\"m\n" +
	"\x06Status\x12\x16\n" +
	"\x12STATUS_UNSPECIFIED\x10\x00\x12\v\n" +
	"\aPENDING\x10\x01\x12\v\n" +
	"\aRUNNING\x10\x02\x12\b\n" +
	"\x04DONE\x10\x03\x12\n" +
	"\n" +
	"\x06FAILED\x10\x04\x12\f\n" +
	"\bCANCELED\x10\x05\x12\r\n" +
	"\tAVAILABLE\x10\x06:q\xeaAn\n" +
	"\x14bytebase.com/TaskRun\x12Vprojects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}B\v\n" +
	"\t_run_timeJ\x04\b\a\x10\tJ\x04\b\n" +
	"\x10\vJ\x04\b\r\x10\x0e\"\xd2\x01\n" +
	"\n" +
	"TaskRunLog\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x126\n" +
	"\aentries\x18\x02 \x03(\v2\x1c.bytebase.v1.TaskRunLogEntryR\aentries:x\xeaAu\n" +
	"\x17bytebase.com/TaskRunLog\x12Zprojects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}/log\"\xf7\x19\n" +
	"\x0fTaskRunLogEntry\x125\n" +
	"\x04type\x18\x01 \x01(\x0e2!.bytebase.v1.TaskRunLogEntry.TypeR\x04type\x125\n" +
	"\blog_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\alogTime\x12\x1d\n" +
	"\n" +
	"replica_id\x18\x03 \x01(\tR\treplicaId\x12H\n" +
	"\vschema_dump\x18\x04 \x01(\v2'.bytebase.v1.TaskRunLogEntry.SchemaDumpR\n" +
	"schemaDump\x12T\n" +
	"\x0fcommand_execute\x18\x05 \x01(\v2+.bytebase.v1.TaskRunLogEntry.CommandExecuteR\x0ecommandExecute\x12N\n" +
	"\rdatabase_sync\x18\x06 \x01(\v2).bytebase.v1.TaskRunLogEntry.DatabaseSyncR\fdatabaseSync\x12`\n" +
	"\x13transaction_control\x18\b \x01(\v2/.bytebase.v1.TaskRunLogEntry.TransactionControlR\x12transactionControl\x12K\n" +
	"\fprior_backup\x18\t \x01(\v2(.bytebase.v1.TaskRunLogEntry.PriorBackupR\vpriorBackup\x12E\n" +
	"\n" +
	"retry_info\x18\n" +
	" \x01(\v2&.bytebase.v1.TaskRunLogEntry.RetryInfoR\tretryInfo\x12K\n" +
	"\fcompute_diff\x18\v \x01(\v2(.bytebase.v1.TaskRunLogEntry.ComputeDiffR\vcomputeDiff\x12a\n" +
	"\x14release_file_execute\x18\f \x01(\v2/.bytebase.v1.TaskRunLogEntry.ReleaseFileExecuteR\x12releaseFileExecute\x12T\n" +
	"\x0fghost_migration\x18\r \x01(\v2+.bytebase.v1.TaskRunLogEntry.GhostMigrationR\x0eghostMigration\x1a\x94\x01\n" +
	"\n" +
	"SchemaDump\x129\n" +
	"\n" +
	"start_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x125\n" +
	"\bend_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12\x14\n" +
	"\x05error\x18\x03 \x01(\tR\x05error\x1a\x9a\x03\n" +
	"\x0eCommandExecute\x125\n" +
	"\blog_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\alogTime\x12(\n" +
	"\x05range\x18\x02 \x01(\v2\x12.bytebase.v1.RangeR\x05range\x12\x1c\n" +
	"\tstatement\x18\x04 \x01(\tR\tstatement\x12W\n" +
	"\bresponse\x18\x03 \x01(\v2;.bytebase.v1.TaskRunLogEntry.CommandExecute.CommandResponseR\bresponse\x1a\xaf\x01\n" +
	"\x0fCommandResponse\x125\n" +
	"\blog_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\alogTime\x12\x14\n" +
	"\x05error\x18\x02 \x01(\tR\x05error\x12#\n" +
	"\raffected_rows\x18\x03 \x01(\x03R\faffectedRows\x12*\n" +
	"\x11all_affected_rows\x18\x04 \x03(\x03R\x0fallAffectedRows\x1a\x96\x01\n" +
	"\fDatabaseSync\x129\n" +
	"\n" +
	"start_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x125\n" +
	"\bend_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12\x14\n" +
	"\x05error\x18\x03 \x01(\tR\x05error\x1a\xb7\x01\n" +
	"\x12TransactionControl\x12H\n" +
	"\x04type\x18\x01 \x01(\x0e24.bytebase.v1.TaskRunLogEntry.TransactionControl.TypeR\x04type\x12\x14\n" +
	"\x05error\x18\x02 \x01(\tR\x05error\"A\n" +
	"\x04Type\x12\x14\n" +
	"\x10TYPE_UNSPECIFIED\x10\x00\x12\t\n" +
	"\x05BEGIN\x10\x01\x12\n" +
	"\n" +
	"\x06COMMIT\x10\x02\x12\f\n" +
	"\bROLLBACK\x10\x03\x1a\x96\x06\n" +
	"\vPriorBackup\x129\n" +
	"\n" +
	"start_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x125\n" +
	"\bend_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12j\n" +
	"\x13prior_backup_detail\x18\x03 \x01(\v2:.bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetailR\x11priorBackupDetail\x12\x14\n" +
	"\x05error\x18\x04 \x01(\tR\x05error\x1a\x92\x04\n" +
	"\x11PriorBackupDetail\x12U\n" +
	"\x05items\x18\x01 \x03(\v2?.bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.ItemR\x05items\x1a\xa5\x03\n" +
	"\x04Item\x12h\n" +
	"\fsource_table\x18\x01 \x01(\v2E.bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item.TableR\vsourceTable\x12h\n" +
	"\ftarget_table\x18\x02 \x01(\v2E.bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item.TableR\vtargetTable\x12<\n" +
	"\x0estart_position\x18\x03 \x01(\v2\x15.bytebase.v1.PositionR\rstartPosition\x128\n" +
	"\fend_position\x18\x04 \x01(\v2\x15.bytebase.v1.PositionR\vendPosition\x1aQ\n" +
	"\x05Table\x12\x1a\n" +
	"\bdatabase\x18\x01 \x01(\tR\bdatabase\x12\x16\n" +
	"\x06schema\x18\x02 \x01(\tR\x06schema\x12\x14\n" +
	"\x05table\x18\x03 \x01(\tR\x05table\x1ak\n" +
	"\tRetryInfo\x12\x14\n" +
	"\x05error\x18\x01 \x01(\tR\x05error\x12\x1f\n" +
	"\vretry_count\x18\x02 \x01(\x05R\n" +
	"retryCount\x12'\n" +
	"\x0fmaximum_retries\x18\x03 \x01(\x05R\x0emaximumRetries\x1a\x95\x01\n" +
	"\vComputeDiff\x129\n" +
	"\n" +
	"start_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x125\n" +
	"\bend_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12\x14\n" +
	"\x05error\x18\x03 \x01(\tR\x05error\x1a\x98\x01\n" +
	"\x0eGhostMigration\x129\n" +
	"\n" +
	"start_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x125\n" +
	"\bend_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12\x14\n" +
	"\x05error\x18\x03 \x01(\tR\x05error\x1aK\n" +
	"\x12ReleaseFileExecute\x12\x18\n" +
	"\aversion\x18\x01 \x01(\tR\aversion\x12\x1b\n" +
	"\tfile_path\x18\x02 \x01(\tR\bfilePath\"\xd7\x01\n" +
	"\x04Type\x12\x14\n" +
	"\x10TYPE_UNSPECIFIED\x10\x00\x12\x0f\n" +
	"\vSCHEMA_DUMP\x10\x01\x12\x13\n" +
	"\x0fCOMMAND_EXECUTE\x10\x02\x12\x11\n" +
	"\rDATABASE_SYNC\x10\x03\x12\x17\n" +
	"\x13TRANSACTION_CONTROL\x10\x05\x12\x10\n" +
	"\fPRIOR_BACKUP\x10\x06\x12\x0e\n" +
	"\n" +
	"RETRY_INFO\x10\a\x12\x10\n" +
	"\fCOMPUTE_DIFF\x10\b\x12\x18\n" +
	"\x14RELEASE_FILE_EXECUTE\x10\t\x12\x13\n" +
	"\x0fGHOST_MIGRATION\x10\n" +
	"\"\x04\b\x04\x10\x04J\x04\b\a\x10\b\"P\n" +
	"\x18GetTaskRunSessionRequest\x124\n" +
	"\x06parent\x18\x01 \x01(\tB\x1c\xe0A\x02\xfaA\x16\n" +
	"\x14bytebase.com/TaskRunR\x06parent\"\xc3\t\n" +
	"\x0eTaskRunSession\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12B\n" +
	"\bpostgres\x18\x02 \x01(\v2$.bytebase.v1.TaskRunSession.PostgresH\x00R\bpostgres\x1a\xca\a\n" +
	"\bPostgres\x12F\n" +
	"\asession\x18\x01 \x01(\v2,.bytebase.v1.TaskRunSession.Postgres.SessionR\asession\x12Y\n" +
	"\x11blocking_sessions\x18\x02 \x03(\v2,.bytebase.v1.TaskRunSession.Postgres.SessionR\x10blockingSessions\x12W\n" +
	"\x10blocked_sessions\x18\x03 \x03(\v2,.bytebase.v1.TaskRunSession.Postgres.SessionR\x0fblockedSessions\x1a\xc1\x05\n" +
	"\aSession\x12\x10\n" +
	"\x03pid\x18\x01 \x01(\tR\x03pid\x12&\n" +
	"\x0fblocked_by_pids\x18\x02 \x03(\tR\rblockedByPids\x12\x14\n" +
	"\x05query\x18\x03 \x01(\tR\x05query\x12\x19\n" +
	"\x05state\x18\x04 \x01(\tH\x00R\x05state\x88\x01\x01\x12+\n" +
	"\x0fwait_event_type\x18\x05 \x01(\tH\x01R\rwaitEventType\x88\x01\x01\x12\"\n" +
	"\n" +
	"wait_event\x18\x06 \x01(\tH\x02R\twaitEvent\x88\x01\x01\x12\x1d\n" +
	"\adatname\x18\a \x01(\tH\x03R\adatname\x88\x01\x01\x12\x1d\n" +
	"\ausename\x18\b \x01(\tH\x04R\ausename\x88\x01\x01\x12)\n" +
	"\x10application_name\x18\t \x01(\tR\x0fapplicationName\x12$\n" +
	"\vclient_addr\x18\n" +
	" \x01(\tH\x05R\n" +
	"clientAddr\x88\x01\x01\x12$\n" +
	"\vclient_port\x18\v \x01(\tH\x06R\n" +
	"clientPort\x88\x01\x01\x12?\n" +
	"\rbackend_start\x18\f \x01(\v2\x1a.google.protobuf.TimestampR\fbackendStart\x12>\n" +
	"\n" +
	"xact_start\x18\r \x01(\v2\x1a.google.protobuf.TimestampH\aR\txactStart\x88\x01\x01\x12@\n" +
	"\vquery_start\x18\x0e \x01(\v2\x1a.google.protobuf.TimestampH\bR\n" +
	"queryStart\x88\x01\x01B\b\n" +
	"\x06_stateB\x12\n" +
	"\x10_wait_event_typeB\r\n" +
	"\v_wait_eventB\n" +
	"\n" +
	"\b_datnameB\n" +
	"\n" +
	"\b_usenameB\x0e\n" +
	"\f_client_addrB\x0e\n" +
	"\f_client_portB\r\n" +
	"\v_xact_startB\x0e\n" +
	"\f_query_start:\x80\x01\xeaA}\n" +
	"\x1bbytebase.com/TaskRunSession\x12^projects/{project}/plans/{plan}/rollout/stages/{stage}/tasks/{task}/taskRuns/{taskRun}/sessionB\t\n" +
	"\asession\"Q\n" +
	"\x1dPreviewTaskRunRollbackRequest\x120\n" +
	"\x04name\x18\x01 \x01(\tB\x1c\xe0A\x02\xfaA\x16\n" +
	"\x14bytebase.com/TaskRunR\x04name\">\n" +
	"\x1ePreviewTaskRunRollbackResponse\x12\x1c\n" +
	"\tstatement\x18\x01 \x01(\tR\tstatement2\xbb\x10\n" +
	"\x0eRolloutService\x12\x93\x01\n" +
	"\n" +
	"GetRollout\x12\x1e.bytebase.v1.GetRolloutRequest\x1a\x14.bytebase.v1.Rollout\"O\xdaA\x04name\x8a\xea0\x0fbb.rollouts.get\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02'\x12%/v1/{name=projects/*/plans/*/rollout}\x12\xa2\x01\n" +
	"\fListRollouts\x12 .bytebase.v1.ListRolloutsRequest\x1a!.bytebase.v1.ListRolloutsResponse\"M\xdaA\x06parent\x8a\xea0\x10bb.rollouts.list\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02\"\x12 /v1/{parent=projects/*}/rollouts\x12\x91\x01\n" +
	"\rCreateRollout\x12!.bytebase.v1.CreateRolloutRequest\x1a\x14.bytebase.v1.Rollout\"G\xdaA\x06parent\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02,:\x01*\"'/v1/{parent=projects/*/plans/*}/rollout\x12\xc3\x01\n" +
	"\fListTaskRuns\x12 .bytebase.v1.ListTaskRunsRequest\x1a!.bytebase.v1.ListTaskRunsResponse\"n\xdaA\x06parent\x8a\xea0\x10bb.taskRuns.list\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02C\x12A/v1/{parent=projects/*/plans/*/rollout/stages/*/tasks/*}/taskRuns\x12\xb0\x01\n" +
	"\n" +
	"GetTaskRun\x12\x1e.bytebase.v1.GetTaskRunRequest\x1a\x14.bytebase.v1.TaskRun\"l\xdaA\x04name\x8a\xea0\x10bb.taskRuns.list\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02C\x12A/v1/{name=projects/*/plans/*/rollout/stages/*/tasks/*/taskRuns/*}\x12\xc1\x01\n" +
	"\rGetTaskRunLog\x12!.bytebase.v1.GetTaskRunLogRequest\x1a\x17.bytebase.v1.TaskRunLog\"t\xdaA\x06parent\x8a\xea0\x10bb.taskRuns.list\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02I\x12G/v1/{parent=projects/*/plans/*/rollout/stages/*/tasks/*/taskRuns/*}/log\x12\xd5\x01\n" +
	"\x11GetTaskRunSession\x12%.bytebase.v1.GetTaskRunSessionRequest\x1a\x1b.bytebase.v1.TaskRunSession\"|\xdaA\x06parent\x8a\xea0\x10bb.taskRuns.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\v\x82\xd3\xe4\x93\x02M\x12K/v1/{parent=projects/*/plans/*/rollout/stages/*/tasks/*/taskRuns/*}/session\x12\xb7\x01\n" +
	"\rBatchRunTasks\x12!.bytebase.v1.BatchRunTasksRequest\x1a\".bytebase.v1.BatchRunTasksResponse\"_\xdaA\x06parent\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02D:\x01*\"?/v1/{parent=projects/*/plans/*/rollout/stages/*}/tasks:batchRun\x12\xbb\x01\n" +
	"\x0eBatchSkipTasks\x12\".bytebase.v1.BatchSkipTasksRequest\x1a#.bytebase.v1.BatchSkipTasksResponse\"`\xdaA\x06parent\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02E:\x01*\"@/v1/{parent=projects/*/plans/*/rollout/stages/*}/tasks:batchSkip\x12\xd7\x01\n" +
	"\x13BatchCancelTaskRuns\x12'.bytebase.v1.BatchCancelTaskRunsRequest\x1a(.bytebase.v1.BatchCancelTaskRunsResponse\"m\xdaA\x06parent\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02R:\x01*\"M/v1/{parent=projects/*/plans/*/rollout/stages/*/tasks/*}/taskRuns:batchCancel\x12\xf2\x01\n" +
	"\x16PreviewTaskRunRollback\x12*.bytebase.v1.PreviewTaskRunRollbackRequest\x1a+.bytebase.v1.PreviewTaskRunRollbackResponse\"\x7f\xdaA\x04name\x8a\xea0\x10bb.taskRuns.list\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02V:\x01*\"Q/v1/{name=projects/*/plans/*/rollout/stages/*/tasks/*/taskRuns/*}:previewRollbackB\xa9\x01\n" +
	"\x0fcom.bytebase.v1B\x13RolloutServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"

var (
	file_v1_rollout_service_proto_rawDescOnce sync.Once
	file_v1_rollout_service_proto_rawDescData []byte
)

func file_v1_rollout_service_proto_rawDescGZIP() []byte {
	file_v1_rollout_service_proto_rawDescOnce.Do(func() {
		file_v1_rollout_service_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v1_rollout_service_proto_rawDesc), len(file_v1_rollout_service_proto_rawDesc)))
	})
	return file_v1_rollout_service_proto_rawDescData
}

var file_v1_rollout_service_proto_enumTypes = make([]protoimpl.EnumInfo, 5)
var file_v1_rollout_service_proto_msgTypes = make([]protoimpl.MessageInfo, 43)
var file_v1_rollout_service_proto_goTypes = []any{
	(Task_Status)(0),                                                 // 0: bytebase.v1.Task.Status
	(Task_Type)(0),                                                   // 1: bytebase.v1.Task.Type
	(TaskRun_Status)(0),                                              // 2: bytebase.v1.TaskRun.Status
	(TaskRunLogEntry_Type)(0),                                        // 3: bytebase.v1.TaskRunLogEntry.Type
	(TaskRunLogEntry_TransactionControl_Type)(0),                     // 4: bytebase.v1.TaskRunLogEntry.TransactionControl.Type
	(*BatchRunTasksRequest)(nil),                                     // 5: bytebase.v1.BatchRunTasksRequest
	(*BatchRunTasksResponse)(nil),                                    // 6: bytebase.v1.BatchRunTasksResponse
	(*BatchSkipTasksRequest)(nil),                                    // 7: bytebase.v1.BatchSkipTasksRequest
	(*BatchSkipTasksResponse)(nil),                                   // 8: bytebase.v1.BatchSkipTasksResponse
	(*BatchCancelTaskRunsRequest)(nil),                               // 9: bytebase.v1.BatchCancelTaskRunsRequest
	(*BatchCancelTaskRunsResponse)(nil),                              // 10: bytebase.v1.BatchCancelTaskRunsResponse
	(*GetRolloutRequest)(nil),                                        // 11: bytebase.v1.GetRolloutRequest
	(*ListRolloutsRequest)(nil),                                      // 12: bytebase.v1.ListRolloutsRequest
	(*ListRolloutsResponse)(nil),                                     // 13: bytebase.v1.ListRolloutsResponse
	(*CreateRolloutRequest)(nil),                                     // 14: bytebase.v1.CreateRolloutRequest
	(*ListTaskRunsRequest)(nil),                                      // 15: bytebase.v1.ListTaskRunsRequest
	(*ListTaskRunsResponse)(nil),                                     // 16: bytebase.v1.ListTaskRunsResponse
	(*GetTaskRunRequest)(nil),                                        // 17: bytebase.v1.GetTaskRunRequest
	(*GetTaskRunLogRequest)(nil),                                     // 18: bytebase.v1.GetTaskRunLogRequest
	(*Rollout)(nil),                                                  // 19: bytebase.v1.Rollout
	(*Stage)(nil),                                                    // 20: bytebase.v1.Stage
	(*Task)(nil),                                                     // 21: bytebase.v1.Task
	(*TaskRun)(nil),                                                  // 22: bytebase.v1.TaskRun
	(*TaskRunLog)(nil),                                               // 23: bytebase.v1.TaskRunLog
	(*TaskRunLogEntry)(nil),                                          // 24: bytebase.v1.TaskRunLogEntry
	(*GetTaskRunSessionRequest)(nil),                                 // 25: bytebase.v1.GetTaskRunSessionRequest
	(*TaskRunSession)(nil),                                           // 26: bytebase.v1.TaskRunSession
	(*PreviewTaskRunRollbackRequest)(nil),                            // 27: bytebase.v1.PreviewTaskRunRollbackRequest
	(*PreviewTaskRunRollbackResponse)(nil),                           // 28: bytebase.v1.PreviewTaskRunRollbackResponse
	(*Task_DatabaseCreate)(nil),                                      // 29: bytebase.v1.Task.DatabaseCreate
	(*Task_DatabaseUpdate)(nil),                                      // 30: bytebase.v1.Task.DatabaseUpdate
	(*TaskRun_SchedulerInfo)(nil),                                    // 31: bytebase.v1.TaskRun.SchedulerInfo
	(*TaskRun_SchedulerInfo_WaitingCause)(nil),                       // 32: bytebase.v1.TaskRun.SchedulerInfo.WaitingCause
	(*TaskRunLogEntry_SchemaDump)(nil),                               // 33: bytebase.v1.TaskRunLogEntry.SchemaDump
	(*TaskRunLogEntry_CommandExecute)(nil),                           // 34: bytebase.v1.TaskRunLogEntry.CommandExecute
	(*TaskRunLogEntry_DatabaseSync)(nil),                             // 35: bytebase.v1.TaskRunLogEntry.DatabaseSync
	(*TaskRunLogEntry_TransactionControl)(nil),                       // 36: bytebase.v1.TaskRunLogEntry.TransactionControl
	(*TaskRunLogEntry_PriorBackup)(nil),                              // 37: bytebase.v1.TaskRunLogEntry.PriorBackup
	(*TaskRunLogEntry_RetryInfo)(nil),                                // 38: bytebase.v1.TaskRunLogEntry.RetryInfo
	(*TaskRunLogEntry_ComputeDiff)(nil),                              // 39: bytebase.v1.TaskRunLogEntry.ComputeDiff
	(*TaskRunLogEntry_GhostMigration)(nil),                           // 40: bytebase.v1.TaskRunLogEntry.GhostMigration
	(*TaskRunLogEntry_ReleaseFileExecute)(nil),                       // 41: bytebase.v1.TaskRunLogEntry.ReleaseFileExecute
	(*TaskRunLogEntry_CommandExecute_CommandResponse)(nil),           // 42: bytebase.v1.TaskRunLogEntry.CommandExecute.CommandResponse
	(*TaskRunLogEntry_PriorBackup_PriorBackupDetail)(nil),            // 43: bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail
	(*TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item)(nil),       // 44: bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item
	(*TaskRunLogEntry_PriorBackup_PriorBackupDetail_Item_Table)(nil), // 45: bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item.Table
	(*TaskRunSession_Postgres)(nil),                                  // 46: bytebase.v1.TaskRunSession.Postgres
	(*TaskRunSession_Postgres_Session)(nil),                          // 47: bytebase.v1.TaskRunSession.Postgres.Session
	(*timestamppb.Timestamp)(nil),                                    // 48: google.protobuf.Timestamp
	(*Range)(nil),                                                    // 49: bytebase.v1.Range
	(*Position)(nil),                                                 // 50: bytebase.v1.Position
}
var file_v1_rollout_service_proto_depIdxs = []int32{
	48, // 0: bytebase.v1.BatchRunTasksRequest.run_time:type_name -> google.protobuf.Timestamp
	19, // 1: bytebase.v1.ListRolloutsResponse.rollouts:type_name -> bytebase.v1.Rollout
	22, // 2: bytebase.v1.ListTaskRunsResponse.task_runs:type_name -> bytebase.v1.TaskRun
	20, // 3: bytebase.v1.Rollout.stages:type_name -> bytebase.v1.Stage
	48, // 4: bytebase.v1.Rollout.create_time:type_name -> google.protobuf.Timestamp
	48, // 5: bytebase.v1.Rollout.update_time:type_name -> google.protobuf.Timestamp
	21, // 6: bytebase.v1.Stage.tasks:type_name -> bytebase.v1.Task
	0,  // 7: bytebase.v1.Task.status:type_name -> bytebase.v1.Task.Status
	1,  // 8: bytebase.v1.Task.type:type_name -> bytebase.v1.Task.Type
	29, // 9: bytebase.v1.Task.database_create:type_name -> bytebase.v1.Task.DatabaseCreate
	30, // 10: bytebase.v1.Task.database_update:type_name -> bytebase.v1.Task.DatabaseUpdate
	48, // 11: bytebase.v1.Task.update_time:type_name -> google.protobuf.Timestamp
	48, // 12: bytebase.v1.Task.run_time:type_name -> google.protobuf.Timestamp
	48, // 13: bytebase.v1.TaskRun.create_time:type_name -> google.protobuf.Timestamp
	48, // 14: bytebase.v1.TaskRun.update_time:type_name -> google.protobuf.Timestamp
	2,  // 15: bytebase.v1.TaskRun.status:type_name -> bytebase.v1.TaskRun.Status
	48, // 16: bytebase.v1.TaskRun.start_time:type_name -> google.protobuf.Timestamp
	31, // 17: bytebase.v1.TaskRun.scheduler_info:type_name -> bytebase.v1.TaskRun.SchedulerInfo
	48, // 18: bytebase.v1.TaskRun.run_time:type_name -> google.protobuf.Timestamp
	24, // 19: bytebase.v1.TaskRunLog.entries:type_name -> bytebase.v1.TaskRunLogEntry
	3,  // 20: bytebase.v1.TaskRunLogEntry.type:type_name -> bytebase.v1.TaskRunLogEntry.Type
	48, // 21: bytebase.v1.TaskRunLogEntry.log_time:type_name -> google.protobuf.Timestamp
	33, // 22: bytebase.v1.TaskRunLogEntry.schema_dump:type_name -> bytebase.v1.TaskRunLogEntry.SchemaDump
	34, // 23: bytebase.v1.TaskRunLogEntry.command_execute:type_name -> bytebase.v1.TaskRunLogEntry.CommandExecute
	35, // 24: bytebase.v1.TaskRunLogEntry.database_sync:type_name -> bytebase.v1.TaskRunLogEntry.DatabaseSync
	36, // 25: bytebase.v1.TaskRunLogEntry.transaction_control:type_name -> bytebase.v1.TaskRunLogEntry.TransactionControl
	37, // 26: bytebase.v1.TaskRunLogEntry.prior_backup:type_name -> bytebase.v1.TaskRunLogEntry.PriorBackup
	38, // 27: bytebase.v1.TaskRunLogEntry.retry_info:type_name -> bytebase.v1.TaskRunLogEntry.RetryInfo
	39, // 28: bytebase.v1.TaskRunLogEntry.compute_diff:type_name -> bytebase.v1.TaskRunLogEntry.ComputeDiff
	41, // 29: bytebase.v1.TaskRunLogEntry.release_file_execute:type_name -> bytebase.v1.TaskRunLogEntry.ReleaseFileExecute
	40, // 30: bytebase.v1.TaskRunLogEntry.ghost_migration:type_name -> bytebase.v1.TaskRunLogEntry.GhostMigration
	46, // 31: bytebase.v1.TaskRunSession.postgres:type_name -> bytebase.v1.TaskRunSession.Postgres
	48, // 32: bytebase.v1.TaskRun.SchedulerInfo.report_time:type_name -> google.protobuf.Timestamp
	32, // 33: bytebase.v1.TaskRun.SchedulerInfo.waiting_cause:type_name -> bytebase.v1.TaskRun.SchedulerInfo.WaitingCause
	48, // 34: bytebase.v1.TaskRunLogEntry.SchemaDump.start_time:type_name -> google.protobuf.Timestamp
	48, // 35: bytebase.v1.TaskRunLogEntry.SchemaDump.end_time:type_name -> google.protobuf.Timestamp
	48, // 36: bytebase.v1.TaskRunLogEntry.CommandExecute.log_time:type_name -> google.protobuf.Timestamp
	49, // 37: bytebase.v1.TaskRunLogEntry.CommandExecute.range:type_name -> bytebase.v1.Range
	42, // 38: bytebase.v1.TaskRunLogEntry.CommandExecute.response:type_name -> bytebase.v1.TaskRunLogEntry.CommandExecute.CommandResponse
	48, // 39: bytebase.v1.TaskRunLogEntry.DatabaseSync.start_time:type_name -> google.protobuf.Timestamp
	48, // 40: bytebase.v1.TaskRunLogEntry.DatabaseSync.end_time:type_name -> google.protobuf.Timestamp
	4,  // 41: bytebase.v1.TaskRunLogEntry.TransactionControl.type:type_name -> bytebase.v1.TaskRunLogEntry.TransactionControl.Type
	48, // 42: bytebase.v1.TaskRunLogEntry.PriorBackup.start_time:type_name -> google.protobuf.Timestamp
	48, // 43: bytebase.v1.TaskRunLogEntry.PriorBackup.end_time:type_name -> google.protobuf.Timestamp
	43, // 44: bytebase.v1.TaskRunLogEntry.PriorBackup.prior_backup_detail:type_name -> bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail
	48, // 45: bytebase.v1.TaskRunLogEntry.ComputeDiff.start_time:type_name -> google.protobuf.Timestamp
	48, // 46: bytebase.v1.TaskRunLogEntry.ComputeDiff.end_time:type_name -> google.protobuf.Timestamp
	48, // 47: bytebase.v1.TaskRunLogEntry.GhostMigration.start_time:type_name -> google.protobuf.Timestamp
	48, // 48: bytebase.v1.TaskRunLogEntry.GhostMigration.end_time:type_name -> google.protobuf.Timestamp
	48, // 49: bytebase.v1.TaskRunLogEntry.CommandExecute.CommandResponse.log_time:type_name -> google.protobuf.Timestamp
	44, // 50: bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.items:type_name -> bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item
	45, // 51: bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item.source_table:type_name -> bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item.Table
	45, // 52: bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item.target_table:type_name -> bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item.Table
	50, // 53: bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item.start_position:type_name -> bytebase.v1.Position
	50, // 54: bytebase.v1.TaskRunLogEntry.PriorBackup.PriorBackupDetail.Item.end_position:type_name -> bytebase.v1.Position
	47, // 55: bytebase.v1.TaskRunSession.Postgres.session:type_name -> bytebase.v1.TaskRunSession.Postgres.Session
	47, // 56: bytebase.v1.TaskRunSession.Postgres.blocking_sessions:type_name -> bytebase.v1.TaskRunSession.Postgres.Session
	47, // 57: bytebase.v1.TaskRunSession.Postgres.blocked_sessions:type_name -> bytebase.v1.TaskRunSession.Postgres.Session
	48, // 58: bytebase.v1.TaskRunSession.Postgres.Session.backend_start:type_name -> google.protobuf.Timestamp
	48, // 59: bytebase.v1.TaskRunSession.Postgres.Session.xact_start:type_name -> google.protobuf.Timestamp
	48, // 60: bytebase.v1.TaskRunSession.Postgres.Session.query_start:type_name -> google.protobuf.Timestamp
	11, // 61: bytebase.v1.RolloutService.GetRollout:input_type -> bytebase.v1.GetRolloutRequest
	12, // 62: bytebase.v1.RolloutService.ListRollouts:input_type -> bytebase.v1.ListRolloutsRequest
	14, // 63: bytebase.v1.RolloutService.CreateRollout:input_type -> bytebase.v1.CreateRolloutRequest
	15, // 64: bytebase.v1.RolloutService.ListTaskRuns:input_type -> bytebase.v1.ListTaskRunsRequest
	17, // 65: bytebase.v1.RolloutService.GetTaskRun:input_type -> bytebase.v1.GetTaskRunRequest
	18, // 66: bytebase.v1.RolloutService.GetTaskRunLog:input_type -> bytebase.v1.GetTaskRunLogRequest
	25, // 67: bytebase.v1.RolloutService.GetTaskRunSession:input_type -> bytebase.v1.GetTaskRunSessionRequest
	5,  // 68: bytebase.v1.RolloutService.BatchRunTasks:input_type -> bytebase.v1.BatchRunTasksRequest
	7,  // 69: bytebase.v1.RolloutService.BatchSkipTasks:input_type -> bytebase.v1.BatchSkipTasksRequest
	9,  // 70: bytebase.v1.RolloutService.BatchCancelTaskRuns:input_type -> bytebase.v1.BatchCancelTaskRunsRequest
	27, // 71: bytebase.v1.RolloutService.PreviewTaskRunRollback:input_type -> bytebase.v1.PreviewTaskRunRollbackRequest
	19, // 72: bytebase.v1.RolloutService.GetRollout:output_type -> bytebase.v1.Rollout
	13, // 73: bytebase.v1.RolloutService.ListRollouts:output_type -> bytebase.v1.ListRolloutsResponse
	19, // 74: bytebase.v1.RolloutService.CreateRollout:output_type -> bytebase.v1.Rollout
	16, // 75: bytebase.v1.RolloutService.ListTaskRuns:output_type -> bytebase.v1.ListTaskRunsResponse
	22, // 76: bytebase.v1.RolloutService.GetTaskRun:output_type -> bytebase.v1.TaskRun
	23, // 77: bytebase.v1.RolloutService.GetTaskRunLog:output_type -> bytebase.v1.TaskRunLog
	26, // 78: bytebase.v1.RolloutService.GetTaskRunSession:output_type -> bytebase.v1.TaskRunSession
	6,  // 79: bytebase.v1.RolloutService.BatchRunTasks:output_type -> bytebase.v1.BatchRunTasksResponse
	8,  // 80: bytebase.v1.RolloutService.BatchSkipTasks:output_type -> bytebase.v1.BatchSkipTasksResponse
	10, // 81: bytebase.v1.RolloutService.BatchCancelTaskRuns:output_type -> bytebase.v1.BatchCancelTaskRunsResponse
	28, // 82: bytebase.v1.RolloutService.PreviewTaskRunRollback:output_type -> bytebase.v1.PreviewTaskRunRollbackResponse
	72, // [72:83] is the sub-list for method output_type
	61, // [61:72] is the sub-list for method input_type
	61, // [61:61] is the sub-list for extension type_name
	61, // [61:61] is the sub-list for extension extendee
	0,  // [0:61] is the sub-list for field type_name
}

func init() { file_v1_rollout_service_proto_init() }
func file_v1_rollout_service_proto_init() {
	if File_v1_rollout_service_proto != nil {
		return
	}
	file_v1_annotation_proto_init()
	file_v1_common_proto_init()
	file_v1_rollout_service_proto_msgTypes[0].OneofWrappers = []any{}
	file_v1_rollout_service_proto_msgTypes[9].OneofWrappers = []any{}
	file_v1_rollout_service_proto_msgTypes[16].OneofWrappers = []any{
		(*Task_DatabaseCreate_)(nil),
		(*Task_DatabaseUpdate_)(nil),
	}
	file_v1_rollout_service_proto_msgTypes[17].OneofWrappers = []any{}
	file_v1_rollout_service_proto_msgTypes[21].OneofWrappers = []any{
		(*TaskRunSession_Postgres_)(nil),
	}
	file_v1_rollout_service_proto_msgTypes[25].OneofWrappers = []any{
		(*Task_DatabaseUpdate_Sheet)(nil),
		(*Task_DatabaseUpdate_Release)(nil),
	}
	file_v1_rollout_service_proto_msgTypes[27].OneofWrappers = []any{
		(*TaskRun_SchedulerInfo_WaitingCause_ParallelTasksLimit)(nil),
	}
	file_v1_rollout_service_proto_msgTypes[42].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_rollout_service_proto_rawDesc), len(file_v1_rollout_service_proto_rawDesc)),
			NumEnums:      5,
			NumMessages:   43,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_v1_rollout_service_proto_goTypes,
		DependencyIndexes: file_v1_rollout_service_proto_depIdxs,
		EnumInfos:         file_v1_rollout_service_proto_enumTypes,
		MessageInfos:      file_v1_rollout_service_proto_msgTypes,
	}.Build()
	File_v1_rollout_service_proto = out.File
	file_v1_rollout_service_proto_goTypes = nil
	file_v1_rollout_service_proto_depIdxs = nil
}