// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: heartbeatpb/heartbeat.proto

package heartbeatpb

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type Action int32

const (
	Action_Write Action = 0
	Action_Pass  Action = 1
)

var Action_name = map[int32]string{
	0: "Write",
	1: "Pass",
}

var Action_value = map[string]int32{
	"Write": 0,
	"Pass":  1,
}

func (x Action) String() string {
	return proto.EnumName(Action_name, int32(x))
}

func (Action) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{0}
}

type ScheduleAction int32

const (
	ScheduleAction_Create ScheduleAction = 0
	ScheduleAction_Remove ScheduleAction = 1
)

var ScheduleAction_name = map[int32]string{
	0: "Create",
	1: "Remove",
}

var ScheduleAction_value = map[string]int32{
	"Create": 0,
	"Remove": 1,
}

func (x ScheduleAction) String() string {
	return proto.EnumName(ScheduleAction_name, int32(x))
}

func (ScheduleAction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{1}
}

type OperatorType int32

const (
	OperatorType_O_Add    OperatorType = 0
	OperatorType_O_Remove OperatorType = 1
	OperatorType_O_Move   OperatorType = 2
	OperatorType_O_Split  OperatorType = 3
	OperatorType_O_Merge  OperatorType = 4
)

var OperatorType_name = map[int32]string{
	0: "O_Add",
	1: "O_Remove",
	2: "O_Move",
	3: "O_Split",
	4: "O_Merge",
}

var OperatorType_value = map[string]int32{
	"O_Add":    0,
	"O_Remove": 1,
	"O_Move":   2,
	"O_Split":  3,
	"O_Merge":  4,
}

func (x OperatorType) String() string {
	return proto.EnumName(OperatorType_name, int32(x))
}

func (OperatorType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{2}
}

type BlockStage int32

const (
	BlockStage_NONE    BlockStage = 0
	BlockStage_WAITING BlockStage = 1
	BlockStage_WRITING BlockStage = 2
	BlockStage_DONE    BlockStage = 3
)

var BlockStage_name = map[int32]string{
	0: "NONE",
	1: "WAITING",
	2: "WRITING",
	3: "DONE",
}

var BlockStage_value = map[string]int32{
	"NONE":    0,
	"WAITING": 1,
	"WRITING": 2,
	"DONE":    3,
}

func (x BlockStage) String() string {
	return proto.EnumName(BlockStage_name, int32(x))
}

func (BlockStage) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{3}
}

type InfluenceType int32

const (
	InfluenceType_All    InfluenceType = 0
	InfluenceType_DB     InfluenceType = 1
	InfluenceType_Normal InfluenceType = 2
)

var InfluenceType_name = map[int32]string{
	0: "All",
	1: "DB",
	2: "Normal",
}

var InfluenceType_value = map[string]int32{
	"All":    0,
	"DB":     1,
	"Normal": 2,
}

func (x InfluenceType) String() string {
	return proto.EnumName(InfluenceType_name, int32(x))
}

func (InfluenceType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{4}
}

type ComponentState int32

const (
	ComponentState_Working      ComponentState = 0
	ComponentState_Stopped      ComponentState = 1
	ComponentState_Removed      ComponentState = 2
	ComponentState_Initializing ComponentState = 3
	ComponentState_Preparing    ComponentState = 4
	ComponentState_MergeReady   ComponentState = 5
	ComponentState_WaitingMerge ComponentState = 6
)

var ComponentState_name = map[int32]string{
	0: "Working",
	1: "Stopped",
	2: "Removed",
	3: "Initializing",
	4: "Preparing",
	5: "MergeReady",
	6: "WaitingMerge",
}

var ComponentState_value = map[string]int32{
	"Working":      0,
	"Stopped":      1,
	"Removed":      2,
	"Initializing": 3,
	"Preparing":    4,
	"MergeReady":   5,
	"WaitingMerge": 6,
}

func (x ComponentState) String() string {
	return proto.EnumName(ComponentState_name, int32(x))
}

func (ComponentState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{5}
}

type ChecksumState int32

const (
	// UNINITIALIZED is the default value when the field is absent in proto3.
	// It must block checkpoint advancement until the checksum is explicitly verified as OK.
	ChecksumState_UNINITIALIZED ChecksumState = 0
	// MISMATCH means the checksum comparison failed. We need to block forwarding checkpointTs.
	ChecksumState_MISMATCH ChecksumState = 1
	// MATCH means the checksum comparison is successful. We can forward checkpointTs.
	ChecksumState_MATCH ChecksumState = 2
)

var ChecksumState_name = map[int32]string{
	0: "UNINITIALIZED",
	1: "MISMATCH",
	2: "MATCH",
}

var ChecksumState_value = map[string]int32{
	"UNINITIALIZED": 0,
	"MISMATCH":      1,
	"MATCH":         2,
}

func (x ChecksumState) String() string {
	return proto.EnumName(ChecksumState_name, int32(x))
}

func (ChecksumState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{6}
}

type TableSpan struct {
	TableID    int64  `protobuf:"varint,1,opt,name=TableID,proto3" json:"TableID,omitempty"`
	StartKey   []byte `protobuf:"bytes,2,opt,name=StartKey,proto3" json:"StartKey,omitempty"`
	EndKey     []byte `protobuf:"bytes,3,opt,name=EndKey,proto3" json:"EndKey,omitempty"`
	KeyspaceID uint32 `protobuf:"varint,4,opt,name=KeyspaceID,proto3" json:"KeyspaceID,omitempty"`
}

func (m *TableSpan) Reset()         { *m = TableSpan{} }
func (m *TableSpan) String() string { return proto.CompactTextString(m) }
func (*TableSpan) ProtoMessage()    {}
func (*TableSpan) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{0}
}
func (m *TableSpan) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableSpan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TableSpan.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TableSpan) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableSpan.Merge(m, src)
}
func (m *TableSpan) XXX_Size() int {
	return m.Size()
}
func (m *TableSpan) XXX_DiscardUnknown() {
	xxx_messageInfo_TableSpan.DiscardUnknown(m)
}

var xxx_messageInfo_TableSpan proto.InternalMessageInfo

func (m *TableSpan) GetTableID() int64 {
	if m != nil {
		return m.TableID
	}
	return 0
}

func (m *TableSpan) GetStartKey() []byte {
	if m != nil {
		return m.StartKey
	}
	return nil
}

func (m *TableSpan) GetEndKey() []byte {
	if m != nil {
		return m.EndKey
	}
	return nil
}

func (m *TableSpan) GetKeyspaceID() uint32 {
	if m != nil {
		return m.KeyspaceID
	}
	return 0
}

type HeartBeatRequest struct {
	ChangefeedID    *ChangefeedID      `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	Watermark       *Watermark         `protobuf:"bytes,2,opt,name=watermark,proto3" json:"watermark,omitempty"`
	RedoWatermark   *Watermark         `protobuf:"bytes,3,opt,name=redoWatermark,proto3" json:"redoWatermark,omitempty"`
	Statuses        []*TableSpanStatus `protobuf:"bytes,4,rep,name=statuses,proto3" json:"statuses,omitempty"`
	CompeleteStatus bool               `protobuf:"varint,5,opt,name=compeleteStatus,proto3" json:"compeleteStatus,omitempty"`
	Err             *RunningError      `protobuf:"bytes,6,opt,name=err,proto3" json:"err,omitempty"`
}

func (m *HeartBeatRequest) Reset()         { *m = HeartBeatRequest{} }
func (m *HeartBeatRequest) String() string { return proto.CompactTextString(m) }
func (*HeartBeatRequest) ProtoMessage()    {}
func (*HeartBeatRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{1}
}
func (m *HeartBeatRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HeartBeatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HeartBeatRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HeartBeatRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeartBeatRequest.Merge(m, src)
}
func (m *HeartBeatRequest) XXX_Size() int {
	return m.Size()
}
func (m *HeartBeatRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_HeartBeatRequest.DiscardUnknown(m)
}

var xxx_messageInfo_HeartBeatRequest proto.InternalMessageInfo

func (m *HeartBeatRequest) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *HeartBeatRequest) GetWatermark() *Watermark {
	if m != nil {
		return m.Watermark
	}
	return nil
}

func (m *HeartBeatRequest) GetRedoWatermark() *Watermark {
	if m != nil {
		return m.RedoWatermark
	}
	return nil
}

func (m *HeartBeatRequest) GetStatuses() []*TableSpanStatus {
	if m != nil {
		return m.Statuses
	}
	return nil
}

func (m *HeartBeatRequest) GetCompeleteStatus() bool {
	if m != nil {
		return m.CompeleteStatus
	}
	return false
}

func (m *HeartBeatRequest) GetErr() *RunningError {
	if m != nil {
		return m.Err
	}
	return nil
}

type Watermark struct {
	CheckpointTs uint64 `protobuf:"varint,1,opt,name=checkpointTs,proto3" json:"checkpointTs,omitempty"`
	ResolvedTs   uint64 `protobuf:"varint,2,opt,name=resolvedTs,proto3" json:"resolvedTs,omitempty"`
	Seq          uint64 `protobuf:"varint,3,opt,name=seq,proto3" json:"seq,omitempty"`
	LastSyncedTs uint64 `protobuf:"varint,4,opt,name=lastSyncedTs,proto3" json:"lastSyncedTs,omitempty"`
}

func (m *Watermark) Reset()         { *m = Watermark{} }
func (m *Watermark) String() string { return proto.CompactTextString(m) }
func (*Watermark) ProtoMessage()    {}
func (*Watermark) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{2}
}
func (m *Watermark) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Watermark) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Watermark.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Watermark) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Watermark.Merge(m, src)
}
func (m *Watermark) XXX_Size() int {
	return m.Size()
}
func (m *Watermark) XXX_DiscardUnknown() {
	xxx_messageInfo_Watermark.DiscardUnknown(m)
}

var xxx_messageInfo_Watermark proto.InternalMessageInfo

func (m *Watermark) GetCheckpointTs() uint64 {
	if m != nil {
		return m.CheckpointTs
	}
	return 0
}

func (m *Watermark) GetResolvedTs() uint64 {
	if m != nil {
		return m.ResolvedTs
	}
	return 0
}

func (m *Watermark) GetSeq() uint64 {
	if m != nil {
		return m.Seq
	}
	return 0
}

func (m *Watermark) GetLastSyncedTs() uint64 {
	if m != nil {
		return m.LastSyncedTs
	}
	return 0
}

type DispatcherAction struct {
	Action      Action `protobuf:"varint,1,opt,name=action,proto3,enum=heartbeatpb.Action" json:"action,omitempty"`
	CommitTs    uint64 `protobuf:"varint,2,opt,name=CommitTs,proto3" json:"CommitTs,omitempty"`
	IsSyncPoint bool   `protobuf:"varint,3,opt,name=IsSyncPoint,proto3" json:"IsSyncPoint,omitempty"`
}

func (m *DispatcherAction) Reset()         { *m = DispatcherAction{} }
func (m *DispatcherAction) String() string { return proto.CompactTextString(m) }
func (*DispatcherAction) ProtoMessage()    {}
func (*DispatcherAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{3}
}
func (m *DispatcherAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DispatcherAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DispatcherAction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DispatcherAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DispatcherAction.Merge(m, src)
}
func (m *DispatcherAction) XXX_Size() int {
	return m.Size()
}
func (m *DispatcherAction) XXX_DiscardUnknown() {
	xxx_messageInfo_DispatcherAction.DiscardUnknown(m)
}

var xxx_messageInfo_DispatcherAction proto.InternalMessageInfo

func (m *DispatcherAction) GetAction() Action {
	if m != nil {
		return m.Action
	}
	return Action_Write
}

func (m *DispatcherAction) GetCommitTs() uint64 {
	if m != nil {
		return m.CommitTs
	}
	return 0
}

func (m *DispatcherAction) GetIsSyncPoint() bool {
	if m != nil {
		return m.IsSyncPoint
	}
	return false
}

type ACK struct {
	CommitTs    uint64 `protobuf:"varint,1,opt,name=CommitTs,proto3" json:"CommitTs,omitempty"`
	IsSyncPoint bool   `protobuf:"varint,2,opt,name=IsSyncPoint,proto3" json:"IsSyncPoint,omitempty"`
}

func (m *ACK) Reset()         { *m = ACK{} }
func (m *ACK) String() string { return proto.CompactTextString(m) }
func (*ACK) ProtoMessage()    {}
func (*ACK) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{4}
}
func (m *ACK) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ACK) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ACK.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ACK) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ACK.Merge(m, src)
}
func (m *ACK) XXX_Size() int {
	return m.Size()
}
func (m *ACK) XXX_DiscardUnknown() {
	xxx_messageInfo_ACK.DiscardUnknown(m)
}

var xxx_messageInfo_ACK proto.InternalMessageInfo

func (m *ACK) GetCommitTs() uint64 {
	if m != nil {
		return m.CommitTs
	}
	return 0
}

func (m *ACK) GetIsSyncPoint() bool {
	if m != nil {
		return m.IsSyncPoint
	}
	return false
}

type InfluencedDispatchers struct {
	InfluenceType InfluenceType `protobuf:"varint,1,opt,name=InfluenceType,proto3,enum=heartbeatpb.InfluenceType" json:"InfluenceType,omitempty"`
	// only exist when type is normal
	DispatcherIDs []*DispatcherID `protobuf:"bytes,2,rep,name=DispatcherIDs,proto3" json:"DispatcherIDs,omitempty"`
	// only exist when type is DB.
	SchemaID int64 `protobuf:"varint,3,opt,name=SchemaID,proto3" json:"SchemaID,omitempty"`
	// only exist when type is all or db, and in heartbeat response.
	ExcludeDispatcherId *DispatcherID `protobuf:"bytes,4,opt,name=excludeDispatcherId,proto3" json:"excludeDispatcherId,omitempty"`
}

func (m *InfluencedDispatchers) Reset()         { *m = InfluencedDispatchers{} }
func (m *InfluencedDispatchers) String() string { return proto.CompactTextString(m) }
func (*InfluencedDispatchers) ProtoMessage()    {}
func (*InfluencedDispatchers) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{5}
}
func (m *InfluencedDispatchers) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InfluencedDispatchers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InfluencedDispatchers.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InfluencedDispatchers) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InfluencedDispatchers.Merge(m, src)
}
func (m *InfluencedDispatchers) XXX_Size() int {
	return m.Size()
}
func (m *InfluencedDispatchers) XXX_DiscardUnknown() {
	xxx_messageInfo_InfluencedDispatchers.DiscardUnknown(m)
}

var xxx_messageInfo_InfluencedDispatchers proto.InternalMessageInfo

func (m *InfluencedDispatchers) GetInfluenceType() InfluenceType {
	if m != nil {
		return m.InfluenceType
	}
	return InfluenceType_All
}

func (m *InfluencedDispatchers) GetDispatcherIDs() []*DispatcherID {
	if m != nil {
		return m.DispatcherIDs
	}
	return nil
}

func (m *InfluencedDispatchers) GetSchemaID() int64 {
	if m != nil {
		return m.SchemaID
	}
	return 0
}

func (m *InfluencedDispatchers) GetExcludeDispatcherId() *DispatcherID {
	if m != nil {
		return m.ExcludeDispatcherId
	}
	return nil
}

type DispatcherStatus struct {
	InfluencedDispatchers *InfluencedDispatchers `protobuf:"bytes,1,opt,name=influencedDispatchers,proto3" json:"influencedDispatchers,omitempty"`
	Action                *DispatcherAction      `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"`
	Ack                   *ACK                   `protobuf:"bytes,3,opt,name=ack,proto3" json:"ack,omitempty"`
}

func (m *DispatcherStatus) Reset()         { *m = DispatcherStatus{} }
func (m *DispatcherStatus) String() string { return proto.CompactTextString(m) }
func (*DispatcherStatus) ProtoMessage()    {}
func (*DispatcherStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{6}
}
func (m *DispatcherStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DispatcherStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DispatcherStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DispatcherStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DispatcherStatus.Merge(m, src)
}
func (m *DispatcherStatus) XXX_Size() int {
	return m.Size()
}
func (m *DispatcherStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_DispatcherStatus.DiscardUnknown(m)
}

var xxx_messageInfo_DispatcherStatus proto.InternalMessageInfo

func (m *DispatcherStatus) GetInfluencedDispatchers() *InfluencedDispatchers {
	if m != nil {
		return m.InfluencedDispatchers
	}
	return nil
}

func (m *DispatcherStatus) GetAction() *DispatcherAction {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *DispatcherStatus) GetAck() *ACK {
	if m != nil {
		return m.Ack
	}
	return nil
}

type HeartBeatResponse struct {
	ChangefeedID       *ChangefeedID       `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	DispatcherStatuses []*DispatcherStatus `protobuf:"bytes,2,rep,name=dispatcherStatuses,proto3" json:"dispatcherStatuses,omitempty"`
	Mode               int64               `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
}

func (m *HeartBeatResponse) Reset()         { *m = HeartBeatResponse{} }
func (m *HeartBeatResponse) String() string { return proto.CompactTextString(m) }
func (*HeartBeatResponse) ProtoMessage()    {}
func (*HeartBeatResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{7}
}
func (m *HeartBeatResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HeartBeatResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HeartBeatResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HeartBeatResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeartBeatResponse.Merge(m, src)
}
func (m *HeartBeatResponse) XXX_Size() int {
	return m.Size()
}
func (m *HeartBeatResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_HeartBeatResponse.DiscardUnknown(m)
}

var xxx_messageInfo_HeartBeatResponse proto.InternalMessageInfo

func (m *HeartBeatResponse) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *HeartBeatResponse) GetDispatcherStatuses() []*DispatcherStatus {
	if m != nil {
		return m.DispatcherStatuses
	}
	return nil
}

func (m *HeartBeatResponse) GetMode() int64 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type CheckpointTsMessage struct {
	ChangefeedID *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	CheckpointTs uint64        `protobuf:"varint,2,opt,name=checkpointTs,proto3" json:"checkpointTs,omitempty"`
}

func (m *CheckpointTsMessage) Reset()         { *m = CheckpointTsMessage{} }
func (m *CheckpointTsMessage) String() string { return proto.CompactTextString(m) }
func (*CheckpointTsMessage) ProtoMessage()    {}
func (*CheckpointTsMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{8}
}
func (m *CheckpointTsMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CheckpointTsMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CheckpointTsMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CheckpointTsMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CheckpointTsMessage.Merge(m, src)
}
func (m *CheckpointTsMessage) XXX_Size() int {
	return m.Size()
}
func (m *CheckpointTsMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_CheckpointTsMessage.DiscardUnknown(m)
}

var xxx_messageInfo_CheckpointTsMessage proto.InternalMessageInfo

func (m *CheckpointTsMessage) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *CheckpointTsMessage) GetCheckpointTs() uint64 {
	if m != nil {
		return m.CheckpointTs
	}
	return 0
}

// RedoMetaMessage used to send unflushed ts to update redo meta
// from maintainer to dispatcher manager
type RedoMetaMessage struct {
	ChangefeedID *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	ResolvedTs   uint64        `protobuf:"varint,2,opt,name=resolvedTs,proto3" json:"resolvedTs,omitempty"`
	CheckpointTs uint64        `protobuf:"varint,3,opt,name=checkpointTs,proto3" json:"checkpointTs,omitempty"`
}

func (m *RedoMetaMessage) Reset()         { *m = RedoMetaMessage{} }
func (m *RedoMetaMessage) String() string { return proto.CompactTextString(m) }
func (*RedoMetaMessage) ProtoMessage()    {}
func (*RedoMetaMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{9}
}
func (m *RedoMetaMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RedoMetaMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RedoMetaMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RedoMetaMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RedoMetaMessage.Merge(m, src)
}
func (m *RedoMetaMessage) XXX_Size() int {
	return m.Size()
}
func (m *RedoMetaMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_RedoMetaMessage.DiscardUnknown(m)
}

var xxx_messageInfo_RedoMetaMessage proto.InternalMessageInfo

func (m *RedoMetaMessage) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *RedoMetaMessage) GetResolvedTs() uint64 {
	if m != nil {
		return m.ResolvedTs
	}
	return 0
}

func (m *RedoMetaMessage) GetCheckpointTs() uint64 {
	if m != nil {
		return m.CheckpointTs
	}
	return 0
}

// RedoResolvedTsProgressMessage used to send redo meta flushed resolvedTs
// from dispatcher manager to maintainer
type RedoResolvedTsProgressMessage struct {
	ChangefeedID *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	ResolvedTs   uint64        `protobuf:"varint,2,opt,name=resolvedTs,proto3" json:"resolvedTs,omitempty"`
}

func (m *RedoResolvedTsProgressMessage) Reset()         { *m = RedoResolvedTsProgressMessage{} }
func (m *RedoResolvedTsProgressMessage) String() string { return proto.CompactTextString(m) }
func (*RedoResolvedTsProgressMessage) ProtoMessage()    {}
func (*RedoResolvedTsProgressMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{10}
}
func (m *RedoResolvedTsProgressMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RedoResolvedTsProgressMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RedoResolvedTsProgressMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RedoResolvedTsProgressMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RedoResolvedTsProgressMessage.Merge(m, src)
}
func (m *RedoResolvedTsProgressMessage) XXX_Size() int {
	return m.Size()
}
func (m *RedoResolvedTsProgressMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_RedoResolvedTsProgressMessage.DiscardUnknown(m)
}

var xxx_messageInfo_RedoResolvedTsProgressMessage proto.InternalMessageInfo

func (m *RedoResolvedTsProgressMessage) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *RedoResolvedTsProgressMessage) GetResolvedTs() uint64 {
	if m != nil {
		return m.ResolvedTs
	}
	return 0
}

// RedoResolvedTsForwardMessage used to send redoGlobalTs (redo meta flushed resolvedTs)
// from maintainer to dispatcher manager
type RedoResolvedTsForwardMessage struct {
	ChangefeedID *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	ResolvedTs   uint64        `protobuf:"varint,2,opt,name=resolvedTs,proto3" json:"resolvedTs,omitempty"`
}

func (m *RedoResolvedTsForwardMessage) Reset()         { *m = RedoResolvedTsForwardMessage{} }
func (m *RedoResolvedTsForwardMessage) String() string { return proto.CompactTextString(m) }
func (*RedoResolvedTsForwardMessage) ProtoMessage()    {}
func (*RedoResolvedTsForwardMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{11}
}
func (m *RedoResolvedTsForwardMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RedoResolvedTsForwardMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RedoResolvedTsForwardMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RedoResolvedTsForwardMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RedoResolvedTsForwardMessage.Merge(m, src)
}
func (m *RedoResolvedTsForwardMessage) XXX_Size() int {
	return m.Size()
}
func (m *RedoResolvedTsForwardMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_RedoResolvedTsForwardMessage.DiscardUnknown(m)
}

var xxx_messageInfo_RedoResolvedTsForwardMessage proto.InternalMessageInfo

func (m *RedoResolvedTsForwardMessage) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *RedoResolvedTsForwardMessage) GetResolvedTs() uint64 {
	if m != nil {
		return m.ResolvedTs
	}
	return 0
}

type DispatcherConfig struct {
	Span         *TableSpan    `protobuf:"bytes,1,opt,name=span,proto3" json:"span,omitempty"`
	StartTs      uint64        `protobuf:"varint,2,opt,name=startTs,proto3" json:"startTs,omitempty"`
	DispatcherID *DispatcherID `protobuf:"bytes,3,opt,name=dispatcherID,proto3" json:"dispatcherID,omitempty"`
	SchemaID     int64         `protobuf:"varint,4,opt,name=schemaID,proto3" json:"schemaID,omitempty"`
	Mode         int64         `protobuf:"varint,5,opt,name=mode,proto3" json:"mode,omitempty"`
	// skipDMLAsStartTs indicates whether to skip DML events at (startTs+1).
	// It is mainly used when a dispatcher is recreated during an in-flight DDL barrier:
	// we need to replay the DDL at blockTs by starting from (blockTs-1), while avoiding
	// potential duplicate DML writes at blockTs.
	SkipDMLAsStartTs bool `protobuf:"varint,6,opt,name=skipDMLAsStartTs,proto3" json:"skipDMLAsStartTs,omitempty"`
}

func (m *DispatcherConfig) Reset()         { *m = DispatcherConfig{} }
func (m *DispatcherConfig) String() string { return proto.CompactTextString(m) }
func (*DispatcherConfig) ProtoMessage()    {}
func (*DispatcherConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{12}
}
func (m *DispatcherConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DispatcherConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DispatcherConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DispatcherConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DispatcherConfig.Merge(m, src)
}
func (m *DispatcherConfig) XXX_Size() int {
	return m.Size()
}
func (m *DispatcherConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_DispatcherConfig.DiscardUnknown(m)
}

var xxx_messageInfo_DispatcherConfig proto.InternalMessageInfo

func (m *DispatcherConfig) GetSpan() *TableSpan {
	if m != nil {
		return m.Span
	}
	return nil
}

func (m *DispatcherConfig) GetStartTs() uint64 {
	if m != nil {
		return m.StartTs
	}
	return 0
}

func (m *DispatcherConfig) GetDispatcherID() *DispatcherID {
	if m != nil {
		return m.DispatcherID
	}
	return nil
}

func (m *DispatcherConfig) GetSchemaID() int64 {
	if m != nil {
		return m.SchemaID
	}
	return 0
}

func (m *DispatcherConfig) GetMode() int64 {
	if m != nil {
		return m.Mode
	}
	return 0
}

func (m *DispatcherConfig) GetSkipDMLAsStartTs() bool {
	if m != nil {
		return m.SkipDMLAsStartTs
	}
	return false
}

type ScheduleDispatcherRequest struct {
	ChangefeedID   *ChangefeedID     `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	Config         *DispatcherConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
	ScheduleAction ScheduleAction    `protobuf:"varint,3,opt,name=scheduleAction,proto3,enum=heartbeatpb.ScheduleAction" json:"scheduleAction,omitempty"`
	OperatorType   OperatorType      `protobuf:"varint,4,opt,name=operatorType,proto3,enum=heartbeatpb.OperatorType" json:"operatorType,omitempty"`
}

func (m *ScheduleDispatcherRequest) Reset()         { *m = ScheduleDispatcherRequest{} }
func (m *ScheduleDispatcherRequest) String() string { return proto.CompactTextString(m) }
func (*ScheduleDispatcherRequest) ProtoMessage()    {}
func (*ScheduleDispatcherRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{13}
}
func (m *ScheduleDispatcherRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ScheduleDispatcherRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ScheduleDispatcherRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ScheduleDispatcherRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScheduleDispatcherRequest.Merge(m, src)
}
func (m *ScheduleDispatcherRequest) XXX_Size() int {
	return m.Size()
}
func (m *ScheduleDispatcherRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ScheduleDispatcherRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ScheduleDispatcherRequest proto.InternalMessageInfo

func (m *ScheduleDispatcherRequest) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *ScheduleDispatcherRequest) GetConfig() *DispatcherConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *ScheduleDispatcherRequest) GetScheduleAction() ScheduleAction {
	if m != nil {
		return m.ScheduleAction
	}
	return ScheduleAction_Create
}

func (m *ScheduleDispatcherRequest) GetOperatorType() OperatorType {
	if m != nil {
		return m.OperatorType
	}
	return OperatorType_O_Add
}

type MergeDispatcherRequest struct {
	ChangefeedID       *ChangefeedID   `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	DispatcherIDs      []*DispatcherID `protobuf:"bytes,2,rep,name=dispatcherIDs,proto3" json:"dispatcherIDs,omitempty"`
	MergedDispatcherID *DispatcherID   `protobuf:"bytes,3,opt,name=mergedDispatcherID,proto3" json:"mergedDispatcherID,omitempty"`
	Mode               int64           `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"`
}

func (m *MergeDispatcherRequest) Reset()         { *m = MergeDispatcherRequest{} }
func (m *MergeDispatcherRequest) String() string { return proto.CompactTextString(m) }
func (*MergeDispatcherRequest) ProtoMessage()    {}
func (*MergeDispatcherRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{14}
}
func (m *MergeDispatcherRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MergeDispatcherRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MergeDispatcherRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MergeDispatcherRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MergeDispatcherRequest.Merge(m, src)
}
func (m *MergeDispatcherRequest) XXX_Size() int {
	return m.Size()
}
func (m *MergeDispatcherRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_MergeDispatcherRequest.DiscardUnknown(m)
}

var xxx_messageInfo_MergeDispatcherRequest proto.InternalMessageInfo

func (m *MergeDispatcherRequest) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *MergeDispatcherRequest) GetDispatcherIDs() []*DispatcherID {
	if m != nil {
		return m.DispatcherIDs
	}
	return nil
}

func (m *MergeDispatcherRequest) GetMergedDispatcherID() *DispatcherID {
	if m != nil {
		return m.MergedDispatcherID
	}
	return nil
}

func (m *MergeDispatcherRequest) GetMode() int64 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type MaintainerHeartbeat struct {
	Statuses []*MaintainerStatus `protobuf:"bytes,1,rep,name=statuses,proto3" json:"statuses,omitempty"`
}

func (m *MaintainerHeartbeat) Reset()         { *m = MaintainerHeartbeat{} }
func (m *MaintainerHeartbeat) String() string { return proto.CompactTextString(m) }
func (*MaintainerHeartbeat) ProtoMessage()    {}
func (*MaintainerHeartbeat) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{15}
}
func (m *MaintainerHeartbeat) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintainerHeartbeat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MaintainerHeartbeat.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MaintainerHeartbeat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintainerHeartbeat.Merge(m, src)
}
func (m *MaintainerHeartbeat) XXX_Size() int {
	return m.Size()
}
func (m *MaintainerHeartbeat) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintainerHeartbeat.DiscardUnknown(m)
}

var xxx_messageInfo_MaintainerHeartbeat proto.InternalMessageInfo

func (m *MaintainerHeartbeat) GetStatuses() []*MaintainerStatus {
	if m != nil {
		return m.Statuses
	}
	return nil
}

type MaintainerStatus struct {
	ChangefeedID  *ChangefeedID   `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	FeedState     string          `protobuf:"bytes,2,opt,name=feed_state,json=feedState,proto3" json:"feed_state,omitempty"`
	State         ComponentState  `protobuf:"varint,3,opt,name=state,proto3,enum=heartbeatpb.ComponentState" json:"state,omitempty"`
	CheckpointTs  uint64          `protobuf:"varint,4,opt,name=checkpoint_ts,json=checkpointTs,proto3" json:"checkpoint_ts,omitempty"`
	Err           []*RunningError `protobuf:"bytes,5,rep,name=err,proto3" json:"err,omitempty"`
	BootstrapDone bool            `protobuf:"varint,6,opt,name=bootstrap_done,json=bootstrapDone,proto3" json:"bootstrap_done,omitempty"`
	LastSyncedTs  uint64          `protobuf:"varint,7,opt,name=lastSyncedTs,proto3" json:"lastSyncedTs,omitempty"`
}

func (m *MaintainerStatus) Reset()         { *m = MaintainerStatus{} }
func (m *MaintainerStatus) String() string { return proto.CompactTextString(m) }
func (*MaintainerStatus) ProtoMessage()    {}
func (*MaintainerStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{16}
}
func (m *MaintainerStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintainerStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MaintainerStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MaintainerStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintainerStatus.Merge(m, src)
}
func (m *MaintainerStatus) XXX_Size() int {
	return m.Size()
}
func (m *MaintainerStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintainerStatus.DiscardUnknown(m)
}

var xxx_messageInfo_MaintainerStatus proto.InternalMessageInfo

func (m *MaintainerStatus) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *MaintainerStatus) GetFeedState() string {
	if m != nil {
		return m.FeedState
	}
	return ""
}

func (m *MaintainerStatus) GetState() ComponentState {
	if m != nil {
		return m.State
	}
	return ComponentState_Working
}

func (m *MaintainerStatus) GetCheckpointTs() uint64 {
	if m != nil {
		return m.CheckpointTs
	}
	return 0
}

func (m *MaintainerStatus) GetErr() []*RunningError {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *MaintainerStatus) GetBootstrapDone() bool {
	if m != nil {
		return m.BootstrapDone
	}
	return false
}

func (m *MaintainerStatus) GetLastSyncedTs() uint64 {
	if m != nil {
		return m.LastSyncedTs
	}
	return 0
}

type CoordinatorBootstrapRequest struct {
	Version int64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
}

func (m *CoordinatorBootstrapRequest) Reset()         { *m = CoordinatorBootstrapRequest{} }
func (m *CoordinatorBootstrapRequest) String() string { return proto.CompactTextString(m) }
func (*CoordinatorBootstrapRequest) ProtoMessage()    {}
func (*CoordinatorBootstrapRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{17}
}
func (m *CoordinatorBootstrapRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CoordinatorBootstrapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CoordinatorBootstrapRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CoordinatorBootstrapRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CoordinatorBootstrapRequest.Merge(m, src)
}
func (m *CoordinatorBootstrapRequest) XXX_Size() int {
	return m.Size()
}
func (m *CoordinatorBootstrapRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CoordinatorBootstrapRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CoordinatorBootstrapRequest proto.InternalMessageInfo

func (m *CoordinatorBootstrapRequest) GetVersion() int64 {
	if m != nil {
		return m.Version
	}
	return 0
}

type CoordinatorBootstrapResponse struct {
	Statuses []*MaintainerStatus `protobuf:"bytes,1,rep,name=statuses,proto3" json:"statuses,omitempty"`
}

func (m *CoordinatorBootstrapResponse) Reset()         { *m = CoordinatorBootstrapResponse{} }
func (m *CoordinatorBootstrapResponse) String() string { return proto.CompactTextString(m) }
func (*CoordinatorBootstrapResponse) ProtoMessage()    {}
func (*CoordinatorBootstrapResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{18}
}
func (m *CoordinatorBootstrapResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CoordinatorBootstrapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CoordinatorBootstrapResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CoordinatorBootstrapResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CoordinatorBootstrapResponse.Merge(m, src)
}
func (m *CoordinatorBootstrapResponse) XXX_Size() int {
	return m.Size()
}
func (m *CoordinatorBootstrapResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CoordinatorBootstrapResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CoordinatorBootstrapResponse proto.InternalMessageInfo

func (m *CoordinatorBootstrapResponse) GetStatuses() []*MaintainerStatus {
	if m != nil {
		return m.Statuses
	}
	return nil
}

type AddMaintainerRequest struct {
	Id              *ChangefeedID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Config          []byte        `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
	CheckpointTs    uint64        `protobuf:"varint,3,opt,name=checkpoint_ts,json=checkpointTs,proto3" json:"checkpoint_ts,omitempty"`
	IsNewChangefeed bool          `protobuf:"varint,4,opt,name=is_new_changefeed,json=isNewChangefeed,proto3" json:"is_new_changefeed,omitempty"`
	KeyspaceId      uint32        `protobuf:"varint,5,opt,name=keyspace_id,json=keyspaceId,proto3" json:"keyspace_id,omitempty"`
}

func (m *AddMaintainerRequest) Reset()         { *m = AddMaintainerRequest{} }
func (m *AddMaintainerRequest) String() string { return proto.CompactTextString(m) }
func (*AddMaintainerRequest) ProtoMessage()    {}
func (*AddMaintainerRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{19}
}
func (m *AddMaintainerRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddMaintainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddMaintainerRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddMaintainerRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddMaintainerRequest.Merge(m, src)
}
func (m *AddMaintainerRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddMaintainerRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddMaintainerRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddMaintainerRequest proto.InternalMessageInfo

func (m *AddMaintainerRequest) GetId() *ChangefeedID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *AddMaintainerRequest) GetConfig() []byte {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *AddMaintainerRequest) GetCheckpointTs() uint64 {
	if m != nil {
		return m.CheckpointTs
	}
	return 0
}

func (m *AddMaintainerRequest) GetIsNewChangefeed() bool {
	if m != nil {
		return m.IsNewChangefeed
	}
	return false
}

func (m *AddMaintainerRequest) GetKeyspaceId() uint32 {
	if m != nil {
		return m.KeyspaceId
	}
	return 0
}

type RemoveMaintainerRequest struct {
	Id         *ChangefeedID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cascade    bool          `protobuf:"varint,2,opt,name=cascade,proto3" json:"cascade,omitempty"`
	Removed    bool          `protobuf:"varint,3,opt,name=removed,proto3" json:"removed,omitempty"`
	KeyspaceId uint32        `protobuf:"varint,4,opt,name=keyspace_id,json=keyspaceId,proto3" json:"keyspace_id,omitempty"`
}

func (m *RemoveMaintainerRequest) Reset()         { *m = RemoveMaintainerRequest{} }
func (m *RemoveMaintainerRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveMaintainerRequest) ProtoMessage()    {}
func (*RemoveMaintainerRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{20}
}
func (m *RemoveMaintainerRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveMaintainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveMaintainerRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemoveMaintainerRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveMaintainerRequest.Merge(m, src)
}
func (m *RemoveMaintainerRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveMaintainerRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveMaintainerRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveMaintainerRequest proto.InternalMessageInfo

func (m *RemoveMaintainerRequest) GetId() *ChangefeedID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *RemoveMaintainerRequest) GetCascade() bool {
	if m != nil {
		return m.Cascade
	}
	return false
}

func (m *RemoveMaintainerRequest) GetRemoved() bool {
	if m != nil {
		return m.Removed
	}
	return false
}

func (m *RemoveMaintainerRequest) GetKeyspaceId() uint32 {
	if m != nil {
		return m.KeyspaceId
	}
	return 0
}

type MaintainerBootstrapRequest struct {
	ChangefeedID                  *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	Config                        []byte        `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
	StartTs                       uint64        `protobuf:"varint,3,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
	TableTriggerEventDispatcherId *DispatcherID `protobuf:"bytes,4,opt,name=table_trigger_event_dispatcher_id,json=tableTriggerEventDispatcherId,proto3" json:"table_trigger_event_dispatcher_id,omitempty"`
	IsNewChangefeed               bool          `protobuf:"varint,5,opt,name=is_new_changefeed,json=isNewChangefeed,proto3" json:"is_new_changefeed,omitempty"`
	TableTriggerRedoDispatcherId  *DispatcherID `protobuf:"bytes,6,opt,name=table_trigger_redo_dispatcher_id,json=tableTriggerRedoDispatcherId,proto3" json:"table_trigger_redo_dispatcher_id,omitempty"`
	KeyspaceId                    uint32        `protobuf:"varint,7,opt,name=keyspace_id,json=keyspaceId,proto3" json:"keyspace_id,omitempty"`
}

func (m *MaintainerBootstrapRequest) Reset()         { *m = MaintainerBootstrapRequest{} }
func (m *MaintainerBootstrapRequest) String() string { return proto.CompactTextString(m) }
func (*MaintainerBootstrapRequest) ProtoMessage()    {}
func (*MaintainerBootstrapRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{21}
}
func (m *MaintainerBootstrapRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintainerBootstrapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MaintainerBootstrapRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MaintainerBootstrapRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintainerBootstrapRequest.Merge(m, src)
}
func (m *MaintainerBootstrapRequest) XXX_Size() int {
	return m.Size()
}
func (m *MaintainerBootstrapRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintainerBootstrapRequest.DiscardUnknown(m)
}

var xxx_messageInfo_MaintainerBootstrapRequest proto.InternalMessageInfo

func (m *MaintainerBootstrapRequest) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *MaintainerBootstrapRequest) GetConfig() []byte {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *MaintainerBootstrapRequest) GetStartTs() uint64 {
	if m != nil {
		return m.StartTs
	}
	return 0
}

func (m *MaintainerBootstrapRequest) GetTableTriggerEventDispatcherId() *DispatcherID {
	if m != nil {
		return m.TableTriggerEventDispatcherId
	}
	return nil
}

func (m *MaintainerBootstrapRequest) GetIsNewChangefeed() bool {
	if m != nil {
		return m.IsNewChangefeed
	}
	return false
}

func (m *MaintainerBootstrapRequest) GetTableTriggerRedoDispatcherId() *DispatcherID {
	if m != nil {
		return m.TableTriggerRedoDispatcherId
	}
	return nil
}

func (m *MaintainerBootstrapRequest) GetKeyspaceId() uint32 {
	if m != nil {
		return m.KeyspaceId
	}
	return 0
}

type MaintainerBootstrapResponse struct {
	ChangefeedID *ChangefeedID         `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	Spans        []*BootstrapTableSpan `protobuf:"bytes,2,rep,name=spans,proto3" json:"spans,omitempty"`
	Err          *RunningError         `protobuf:"bytes,3,opt,name=err,proto3" json:"err,omitempty"`
	// For nodes with a table trigger event dispatcher:
	// - Reports checkpoint_ts in bootstrap response
	// - This checkpoint_ts is used to fetch table lists from schema store during maintainer restart
	// to ensure maintainer's table list stays synchronized with the dispatcher's DDL progress
	// since the dispatcher handles all table creation/deletion DDLs
	//
	// For nodes without a table trigger event dispatcher:
	// - checkpoint_ts is set to 0
	CheckpointTs uint64 `protobuf:"varint,4,opt,name=checkpoint_ts,json=checkpointTs,proto3" json:"checkpoint_ts,omitempty"`
	// redo_checkpoint_ts is similar to checkpoint_ts, for nodes with a table trigger redo dispatcher.
	// It will be used when redo enable.
	RedoCheckpointTs uint64                       `protobuf:"varint,5,opt,name=redo_checkpoint_ts,json=redoCheckpointTs,proto3" json:"redo_checkpoint_ts,omitempty"`
	Operators        []*ScheduleDispatcherRequest `protobuf:"bytes,6,rep,name=operators,proto3" json:"operators,omitempty"`
}

func (m *MaintainerBootstrapResponse) Reset()         { *m = MaintainerBootstrapResponse{} }
func (m *MaintainerBootstrapResponse) String() string { return proto.CompactTextString(m) }
func (*MaintainerBootstrapResponse) ProtoMessage()    {}
func (*MaintainerBootstrapResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{22}
}
func (m *MaintainerBootstrapResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintainerBootstrapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MaintainerBootstrapResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MaintainerBootstrapResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintainerBootstrapResponse.Merge(m, src)
}
func (m *MaintainerBootstrapResponse) XXX_Size() int {
	return m.Size()
}
func (m *MaintainerBootstrapResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintainerBootstrapResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MaintainerBootstrapResponse proto.InternalMessageInfo

func (m *MaintainerBootstrapResponse) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *MaintainerBootstrapResponse) GetSpans() []*BootstrapTableSpan {
	if m != nil {
		return m.Spans
	}
	return nil
}

func (m *MaintainerBootstrapResponse) GetErr() *RunningError {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *MaintainerBootstrapResponse) GetCheckpointTs() uint64 {
	if m != nil {
		return m.CheckpointTs
	}
	return 0
}

func (m *MaintainerBootstrapResponse) GetRedoCheckpointTs() uint64 {
	if m != nil {
		return m.RedoCheckpointTs
	}
	return 0
}

func (m *MaintainerBootstrapResponse) GetOperators() []*ScheduleDispatcherRequest {
	if m != nil {
		return m.Operators
	}
	return nil
}

type MaintainerPostBootstrapRequest struct {
	ChangefeedID                  *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	TableTriggerEventDispatcherId *DispatcherID `protobuf:"bytes,2,opt,name=table_trigger_event_dispatcher_id,json=tableTriggerEventDispatcherId,proto3" json:"table_trigger_event_dispatcher_id,omitempty"`
	Schemas                       []*SchemaInfo `protobuf:"bytes,3,rep,name=schemas,proto3" json:"schemas,omitempty"`
	RedoSchemas                   []*SchemaInfo `protobuf:"bytes,4,rep,name=redo_schemas,json=redoSchemas,proto3" json:"redo_schemas,omitempty"`
}

func (m *MaintainerPostBootstrapRequest) Reset()         { *m = MaintainerPostBootstrapRequest{} }
func (m *MaintainerPostBootstrapRequest) String() string { return proto.CompactTextString(m) }
func (*MaintainerPostBootstrapRequest) ProtoMessage()    {}
func (*MaintainerPostBootstrapRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{23}
}
func (m *MaintainerPostBootstrapRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintainerPostBootstrapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MaintainerPostBootstrapRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MaintainerPostBootstrapRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintainerPostBootstrapRequest.Merge(m, src)
}
func (m *MaintainerPostBootstrapRequest) XXX_Size() int {
	return m.Size()
}
func (m *MaintainerPostBootstrapRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintainerPostBootstrapRequest.DiscardUnknown(m)
}

var xxx_messageInfo_MaintainerPostBootstrapRequest proto.InternalMessageInfo

func (m *MaintainerPostBootstrapRequest) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *MaintainerPostBootstrapRequest) GetTableTriggerEventDispatcherId() *DispatcherID {
	if m != nil {
		return m.TableTriggerEventDispatcherId
	}
	return nil
}

func (m *MaintainerPostBootstrapRequest) GetSchemas() []*SchemaInfo {
	if m != nil {
		return m.Schemas
	}
	return nil
}

func (m *MaintainerPostBootstrapRequest) GetRedoSchemas() []*SchemaInfo {
	if m != nil {
		return m.RedoSchemas
	}
	return nil
}

type MaintainerPostBootstrapResponse struct {
	ChangefeedID                  *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	TableTriggerEventDispatcherId *DispatcherID `protobuf:"bytes,2,opt,name=table_trigger_event_dispatcher_id,json=tableTriggerEventDispatcherId,proto3" json:"table_trigger_event_dispatcher_id,omitempty"`
	Err                           *RunningError `protobuf:"bytes,3,opt,name=err,proto3" json:"err,omitempty"`
}

func (m *MaintainerPostBootstrapResponse) Reset()         { *m = MaintainerPostBootstrapResponse{} }
func (m *MaintainerPostBootstrapResponse) String() string { return proto.CompactTextString(m) }
func (*MaintainerPostBootstrapResponse) ProtoMessage()    {}
func (*MaintainerPostBootstrapResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{24}
}
func (m *MaintainerPostBootstrapResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintainerPostBootstrapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MaintainerPostBootstrapResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MaintainerPostBootstrapResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintainerPostBootstrapResponse.Merge(m, src)
}
func (m *MaintainerPostBootstrapResponse) XXX_Size() int {
	return m.Size()
}
func (m *MaintainerPostBootstrapResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintainerPostBootstrapResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MaintainerPostBootstrapResponse proto.InternalMessageInfo

func (m *MaintainerPostBootstrapResponse) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *MaintainerPostBootstrapResponse) GetTableTriggerEventDispatcherId() *DispatcherID {
	if m != nil {
		return m.TableTriggerEventDispatcherId
	}
	return nil
}

func (m *MaintainerPostBootstrapResponse) GetErr() *RunningError {
	if m != nil {
		return m.Err
	}
	return nil
}

type SchemaInfo struct {
	SchemaID   int64        `protobuf:"varint,1,opt,name=SchemaID,proto3" json:"SchemaID,omitempty"`
	SchemaName string       `protobuf:"bytes,2,opt,name=SchemaName,proto3" json:"SchemaName,omitempty"`
	Tables     []*TableInfo `protobuf:"bytes,3,rep,name=Tables,proto3" json:"Tables,omitempty"`
}

func (m *SchemaInfo) Reset()         { *m = SchemaInfo{} }
func (m *SchemaInfo) String() string { return proto.CompactTextString(m) }
func (*SchemaInfo) ProtoMessage()    {}
func (*SchemaInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{25}
}
func (m *SchemaInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SchemaInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SchemaInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SchemaInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SchemaInfo.Merge(m, src)
}
func (m *SchemaInfo) XXX_Size() int {
	return m.Size()
}
func (m *SchemaInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_SchemaInfo.DiscardUnknown(m)
}

var xxx_messageInfo_SchemaInfo proto.InternalMessageInfo

func (m *SchemaInfo) GetSchemaID() int64 {
	if m != nil {
		return m.SchemaID
	}
	return 0
}

func (m *SchemaInfo) GetSchemaName() string {
	if m != nil {
		return m.SchemaName
	}
	return ""
}

func (m *SchemaInfo) GetTables() []*TableInfo {
	if m != nil {
		return m.Tables
	}
	return nil
}

type TableInfo struct {
	TableID   int64  `protobuf:"varint,1,opt,name=TableID,proto3" json:"TableID,omitempty"`
	TableName string `protobuf:"bytes,2,opt,name=TableName,proto3" json:"TableName,omitempty"`
}

func (m *TableInfo) Reset()         { *m = TableInfo{} }
func (m *TableInfo) String() string { return proto.CompactTextString(m) }
func (*TableInfo) ProtoMessage()    {}
func (*TableInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{26}
}
func (m *TableInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TableInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TableInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableInfo.Merge(m, src)
}
func (m *TableInfo) XXX_Size() int {
	return m.Size()
}
func (m *TableInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TableInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TableInfo proto.InternalMessageInfo

func (m *TableInfo) GetTableID() int64 {
	if m != nil {
		return m.TableID
	}
	return 0
}

func (m *TableInfo) GetTableName() string {
	if m != nil {
		return m.TableName
	}
	return ""
}

type BootstrapTableSpan struct {
	ID              *DispatcherID  `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	SchemaID        int64          `protobuf:"varint,2,opt,name=SchemaID,proto3" json:"SchemaID,omitempty"`
	Span            *TableSpan     `protobuf:"bytes,3,opt,name=span,proto3" json:"span,omitempty"`
	ComponentStatus ComponentState `protobuf:"varint,4,opt,name=component_status,json=componentStatus,proto3,enum=heartbeatpb.ComponentState" json:"component_status,omitempty"`
	CheckpointTs    uint64         `protobuf:"varint,5,opt,name=checkpoint_ts,json=checkpointTs,proto3" json:"checkpoint_ts,omitempty"`
	BlockState      *State         `protobuf:"bytes,6,opt,name=block_state,json=blockState,proto3" json:"block_state,omitempty"`
	Mode            int64          `protobuf:"varint,7,opt,name=mode,proto3" json:"mode,omitempty"`
}

func (m *BootstrapTableSpan) Reset()         { *m = BootstrapTableSpan{} }
func (m *BootstrapTableSpan) String() string { return proto.CompactTextString(m) }
func (*BootstrapTableSpan) ProtoMessage()    {}
func (*BootstrapTableSpan) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{27}
}
func (m *BootstrapTableSpan) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BootstrapTableSpan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BootstrapTableSpan.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BootstrapTableSpan) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BootstrapTableSpan.Merge(m, src)
}
func (m *BootstrapTableSpan) XXX_Size() int {
	return m.Size()
}
func (m *BootstrapTableSpan) XXX_DiscardUnknown() {
	xxx_messageInfo_BootstrapTableSpan.DiscardUnknown(m)
}

var xxx_messageInfo_BootstrapTableSpan proto.InternalMessageInfo

func (m *BootstrapTableSpan) GetID() *DispatcherID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *BootstrapTableSpan) GetSchemaID() int64 {
	if m != nil {
		return m.SchemaID
	}
	return 0
}

func (m *BootstrapTableSpan) GetSpan() *TableSpan {
	if m != nil {
		return m.Span
	}
	return nil
}

func (m *BootstrapTableSpan) GetComponentStatus() ComponentState {
	if m != nil {
		return m.ComponentStatus
	}
	return ComponentState_Working
}

func (m *BootstrapTableSpan) GetCheckpointTs() uint64 {
	if m != nil {
		return m.CheckpointTs
	}
	return 0
}

func (m *BootstrapTableSpan) GetBlockState() *State {
	if m != nil {
		return m.BlockState
	}
	return nil
}

func (m *BootstrapTableSpan) GetMode() int64 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type MaintainerCloseRequest struct {
	ChangefeedID *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	// true when remove changefeed, false when pause the changefeed.
	Removed bool `protobuf:"varint,2,opt,name=removed,proto3" json:"removed,omitempty"`
}

func (m *MaintainerCloseRequest) Reset()         { *m = MaintainerCloseRequest{} }
func (m *MaintainerCloseRequest) String() string { return proto.CompactTextString(m) }
func (*MaintainerCloseRequest) ProtoMessage()    {}
func (*MaintainerCloseRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{28}
}
func (m *MaintainerCloseRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintainerCloseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MaintainerCloseRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MaintainerCloseRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintainerCloseRequest.Merge(m, src)
}
func (m *MaintainerCloseRequest) XXX_Size() int {
	return m.Size()
}
func (m *MaintainerCloseRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintainerCloseRequest.DiscardUnknown(m)
}

var xxx_messageInfo_MaintainerCloseRequest proto.InternalMessageInfo

func (m *MaintainerCloseRequest) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *MaintainerCloseRequest) GetRemoved() bool {
	if m != nil {
		return m.Removed
	}
	return false
}

type MaintainerCloseResponse struct {
	ChangefeedID *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	Success      bool          `protobuf:"varint,2,opt,name=success,proto3" json:"success,omitempty"`
}

func (m *MaintainerCloseResponse) Reset()         { *m = MaintainerCloseResponse{} }
func (m *MaintainerCloseResponse) String() string { return proto.CompactTextString(m) }
func (*MaintainerCloseResponse) ProtoMessage()    {}
func (*MaintainerCloseResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{29}
}
func (m *MaintainerCloseResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintainerCloseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MaintainerCloseResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MaintainerCloseResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintainerCloseResponse.Merge(m, src)
}
func (m *MaintainerCloseResponse) XXX_Size() int {
	return m.Size()
}
func (m *MaintainerCloseResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintainerCloseResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MaintainerCloseResponse proto.InternalMessageInfo

func (m *MaintainerCloseResponse) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *MaintainerCloseResponse) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

type InfluencedTables struct {
	InfluenceType InfluenceType `protobuf:"varint,1,opt,name=InfluenceType,proto3,enum=heartbeatpb.InfluenceType" json:"InfluenceType,omitempty"`
	// only exist when type is normal
	TableIDs []int64 `protobuf:"varint,2,rep,packed,name=TableIDs,proto3" json:"TableIDs,omitempty"`
	// only exist when type is DB.
	SchemaID int64 `protobuf:"varint,3,opt,name=SchemaID,proto3" json:"SchemaID,omitempty"`
}

func (m *InfluencedTables) Reset()         { *m = InfluencedTables{} }
func (m *InfluencedTables) String() string { return proto.CompactTextString(m) }
func (*InfluencedTables) ProtoMessage()    {}
func (*InfluencedTables) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{30}
}
func (m *InfluencedTables) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InfluencedTables) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InfluencedTables.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InfluencedTables) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InfluencedTables.Merge(m, src)
}
func (m *InfluencedTables) XXX_Size() int {
	return m.Size()
}
func (m *InfluencedTables) XXX_DiscardUnknown() {
	xxx_messageInfo_InfluencedTables.DiscardUnknown(m)
}

var xxx_messageInfo_InfluencedTables proto.InternalMessageInfo

func (m *InfluencedTables) GetInfluenceType() InfluenceType {
	if m != nil {
		return m.InfluenceType
	}
	return InfluenceType_All
}

func (m *InfluencedTables) GetTableIDs() []int64 {
	if m != nil {
		return m.TableIDs
	}
	return nil
}

func (m *InfluencedTables) GetSchemaID() int64 {
	if m != nil {
		return m.SchemaID
	}
	return 0
}

type Table struct {
	TableID   int64 `protobuf:"varint,1,opt,name=TableID,proto3" json:"TableID,omitempty"`
	SchemaID  int64 `protobuf:"varint,2,opt,name=SchemaID,proto3" json:"SchemaID,omitempty"`
	Splitable bool  `protobuf:"varint,3,opt,name=Splitable,proto3" json:"Splitable,omitempty"`
}

func (m *Table) Reset()         { *m = Table{} }
func (m *Table) String() string { return proto.CompactTextString(m) }
func (*Table) ProtoMessage()    {}
func (*Table) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{31}
}
func (m *Table) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Table) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Table.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Table) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Table.Merge(m, src)
}
func (m *Table) XXX_Size() int {
	return m.Size()
}
func (m *Table) XXX_DiscardUnknown() {
	xxx_messageInfo_Table.DiscardUnknown(m)
}

var xxx_messageInfo_Table proto.InternalMessageInfo

func (m *Table) GetTableID() int64 {
	if m != nil {
		return m.TableID
	}
	return 0
}

func (m *Table) GetSchemaID() int64 {
	if m != nil {
		return m.SchemaID
	}
	return 0
}

func (m *Table) GetSplitable() bool {
	if m != nil {
		return m.Splitable
	}
	return false
}

type SchemaIDChange struct {
	TableID     int64 `protobuf:"varint,1,opt,name=TableID,proto3" json:"TableID,omitempty"`
	OldSchemaID int64 `protobuf:"varint,2,opt,name=OldSchemaID,proto3" json:"OldSchemaID,omitempty"`
	NewSchemaID int64 `protobuf:"varint,3,opt,name=NewSchemaID,proto3" json:"NewSchemaID,omitempty"`
}

func (m *SchemaIDChange) Reset()         { *m = SchemaIDChange{} }
func (m *SchemaIDChange) String() string { return proto.CompactTextString(m) }
func (*SchemaIDChange) ProtoMessage()    {}
func (*SchemaIDChange) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{32}
}
func (m *SchemaIDChange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SchemaIDChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SchemaIDChange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SchemaIDChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SchemaIDChange.Merge(m, src)
}
func (m *SchemaIDChange) XXX_Size() int {
	return m.Size()
}
func (m *SchemaIDChange) XXX_DiscardUnknown() {
	xxx_messageInfo_SchemaIDChange.DiscardUnknown(m)
}

var xxx_messageInfo_SchemaIDChange proto.InternalMessageInfo

func (m *SchemaIDChange) GetTableID() int64 {
	if m != nil {
		return m.TableID
	}
	return 0
}

func (m *SchemaIDChange) GetOldSchemaID() int64 {
	if m != nil {
		return m.OldSchemaID
	}
	return 0
}

func (m *SchemaIDChange) GetNewSchemaID() int64 {
	if m != nil {
		return m.NewSchemaID
	}
	return 0
}

type State struct {
	IsBlocked         bool              `protobuf:"varint,1,opt,name=IsBlocked,proto3" json:"IsBlocked,omitempty"`
	BlockTs           uint64            `protobuf:"varint,2,opt,name=BlockTs,proto3" json:"BlockTs,omitempty"`
	BlockTables       *InfluencedTables `protobuf:"bytes,3,opt,name=BlockTables,proto3" json:"BlockTables,omitempty"`
	NeedDroppedTables *InfluencedTables `protobuf:"bytes,4,opt,name=NeedDroppedTables,proto3" json:"NeedDroppedTables,omitempty"`
	NeedAddedTables   []*Table          `protobuf:"bytes,5,rep,name=NeedAddedTables,proto3" json:"NeedAddedTables,omitempty"`
	UpdatedSchemas    []*SchemaIDChange `protobuf:"bytes,6,rep,name=UpdatedSchemas,proto3" json:"UpdatedSchemas,omitempty"`
	IsSyncPoint       bool              `protobuf:"varint,7,opt,name=IsSyncPoint,proto3" json:"IsSyncPoint,omitempty"`
	Stage             BlockStage        `protobuf:"varint,8,opt,name=stage,proto3,enum=heartbeatpb.BlockStage" json:"stage,omitempty"`
}

func (m *State) Reset()         { *m = State{} }
func (m *State) String() string { return proto.CompactTextString(m) }
func (*State) ProtoMessage()    {}
func (*State) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{33}
}
func (m *State) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *State) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_State.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *State) XXX_Merge(src proto.Message) {
	xxx_messageInfo_State.Merge(m, src)
}
func (m *State) XXX_Size() int {
	return m.Size()
}
func (m *State) XXX_DiscardUnknown() {
	xxx_messageInfo_State.DiscardUnknown(m)
}

var xxx_messageInfo_State proto.InternalMessageInfo

func (m *State) GetIsBlocked() bool {
	if m != nil {
		return m.IsBlocked
	}
	return false
}

func (m *State) GetBlockTs() uint64 {
	if m != nil {
		return m.BlockTs
	}
	return 0
}

func (m *State) GetBlockTables() *InfluencedTables {
	if m != nil {
		return m.BlockTables
	}
	return nil
}

func (m *State) GetNeedDroppedTables() *InfluencedTables {
	if m != nil {
		return m.NeedDroppedTables
	}
	return nil
}

func (m *State) GetNeedAddedTables() []*Table {
	if m != nil {
		return m.NeedAddedTables
	}
	return nil
}

func (m *State) GetUpdatedSchemas() []*SchemaIDChange {
	if m != nil {
		return m.UpdatedSchemas
	}
	return nil
}

func (m *State) GetIsSyncPoint() bool {
	if m != nil {
		return m.IsSyncPoint
	}
	return false
}

func (m *State) GetStage() BlockStage {
	if m != nil {
		return m.Stage
	}
	return BlockStage_NONE
}

type TableSpanBlockStatus struct {
	ID    *DispatcherID `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	State *State        `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
	Mode  int64         `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
}

func (m *TableSpanBlockStatus) Reset()         { *m = TableSpanBlockStatus{} }
func (m *TableSpanBlockStatus) String() string { return proto.CompactTextString(m) }
func (*TableSpanBlockStatus) ProtoMessage()    {}
func (*TableSpanBlockStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{34}
}
func (m *TableSpanBlockStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableSpanBlockStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TableSpanBlockStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TableSpanBlockStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableSpanBlockStatus.Merge(m, src)
}
func (m *TableSpanBlockStatus) XXX_Size() int {
	return m.Size()
}
func (m *TableSpanBlockStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_TableSpanBlockStatus.DiscardUnknown(m)
}

var xxx_messageInfo_TableSpanBlockStatus proto.InternalMessageInfo

func (m *TableSpanBlockStatus) GetID() *DispatcherID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *TableSpanBlockStatus) GetState() *State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *TableSpanBlockStatus) GetMode() int64 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type TableSpanStatus struct {
	ID                 *DispatcherID  `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	ComponentStatus    ComponentState `protobuf:"varint,2,opt,name=component_status,json=componentStatus,proto3,enum=heartbeatpb.ComponentState" json:"component_status,omitempty"`
	CheckpointTs       uint64         `protobuf:"varint,3,opt,name=checkpoint_ts,json=checkpointTs,proto3" json:"checkpoint_ts,omitempty"`
	EventSizePerSecond float32        `protobuf:"fixed32,4,opt,name=event_size_per_second,json=eventSizePerSecond,proto3" json:"event_size_per_second,omitempty"`
	Mode               int64          `protobuf:"varint,5,opt,name=mode,proto3" json:"mode,omitempty"`
}

func (m *TableSpanStatus) Reset()         { *m = TableSpanStatus{} }
func (m *TableSpanStatus) String() string { return proto.CompactTextString(m) }
func (*TableSpanStatus) ProtoMessage()    {}
func (*TableSpanStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{35}
}
func (m *TableSpanStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableSpanStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TableSpanStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TableSpanStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableSpanStatus.Merge(m, src)
}
func (m *TableSpanStatus) XXX_Size() int {
	return m.Size()
}
func (m *TableSpanStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_TableSpanStatus.DiscardUnknown(m)
}

var xxx_messageInfo_TableSpanStatus proto.InternalMessageInfo

func (m *TableSpanStatus) GetID() *DispatcherID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *TableSpanStatus) GetComponentStatus() ComponentState {
	if m != nil {
		return m.ComponentStatus
	}
	return ComponentState_Working
}

func (m *TableSpanStatus) GetCheckpointTs() uint64 {
	if m != nil {
		return m.CheckpointTs
	}
	return 0
}

func (m *TableSpanStatus) GetEventSizePerSecond() float32 {
	if m != nil {
		return m.EventSizePerSecond
	}
	return 0
}

func (m *TableSpanStatus) GetMode() int64 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type BlockStatusRequest struct {
	ChangefeedID  *ChangefeedID           `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	BlockStatuses []*TableSpanBlockStatus `protobuf:"bytes,2,rep,name=blockStatuses,proto3" json:"blockStatuses,omitempty"`
	Mode          int64                   `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
}

func (m *BlockStatusRequest) Reset()         { *m = BlockStatusRequest{} }
func (m *BlockStatusRequest) String() string { return proto.CompactTextString(m) }
func (*BlockStatusRequest) ProtoMessage()    {}
func (*BlockStatusRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{36}
}
func (m *BlockStatusRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockStatusRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockStatusRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockStatusRequest.Merge(m, src)
}
func (m *BlockStatusRequest) XXX_Size() int {
	return m.Size()
}
func (m *BlockStatusRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockStatusRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BlockStatusRequest proto.InternalMessageInfo

func (m *BlockStatusRequest) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *BlockStatusRequest) GetBlockStatuses() []*TableSpanBlockStatus {
	if m != nil {
		return m.BlockStatuses
	}
	return nil
}

func (m *BlockStatusRequest) GetMode() int64 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type RunningError struct {
	Time    string `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
	Node    string `protobuf:"bytes,2,opt,name=node,proto3" json:"node,omitempty"`
	Code    string `protobuf:"bytes,3,opt,name=code,proto3" json:"code,omitempty"`
	Message string `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
}

func (m *RunningError) Reset()         { *m = RunningError{} }
func (m *RunningError) String() string { return proto.CompactTextString(m) }
func (*RunningError) ProtoMessage()    {}
func (*RunningError) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{37}
}
func (m *RunningError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RunningError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RunningError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RunningError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunningError.Merge(m, src)
}
func (m *RunningError) XXX_Size() int {
	return m.Size()
}
func (m *RunningError) XXX_DiscardUnknown() {
	xxx_messageInfo_RunningError.DiscardUnknown(m)
}

var xxx_messageInfo_RunningError proto.InternalMessageInfo

func (m *RunningError) GetTime() string {
	if m != nil {
		return m.Time
	}
	return ""
}

func (m *RunningError) GetNode() string {
	if m != nil {
		return m.Node
	}
	return ""
}

func (m *RunningError) GetCode() string {
	if m != nil {
		return m.Code
	}
	return ""
}

func (m *RunningError) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type DispatcherID struct {
	High uint64 `protobuf:"varint,1,opt,name=high,proto3" json:"high,omitempty"`
	Low  uint64 `protobuf:"varint,2,opt,name=low,proto3" json:"low,omitempty"`
}

func (m *DispatcherID) Reset()         { *m = DispatcherID{} }
func (m *DispatcherID) String() string { return proto.CompactTextString(m) }
func (*DispatcherID) ProtoMessage()    {}
func (*DispatcherID) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{38}
}
func (m *DispatcherID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DispatcherID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DispatcherID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DispatcherID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DispatcherID.Merge(m, src)
}
func (m *DispatcherID) XXX_Size() int {
	return m.Size()
}
func (m *DispatcherID) XXX_DiscardUnknown() {
	xxx_messageInfo_DispatcherID.DiscardUnknown(m)
}

var xxx_messageInfo_DispatcherID proto.InternalMessageInfo

func (m *DispatcherID) GetHigh() uint64 {
	if m != nil {
		return m.High
	}
	return 0
}

func (m *DispatcherID) GetLow() uint64 {
	if m != nil {
		return m.Low
	}
	return 0
}

type ChangefeedID struct {
	High     uint64 `protobuf:"varint,1,opt,name=high,proto3" json:"high,omitempty"`
	Low      uint64 `protobuf:"varint,2,opt,name=low,proto3" json:"low,omitempty"`
	Name     string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Keyspace string `protobuf:"bytes,4,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
}

func (m *ChangefeedID) Reset()         { *m = ChangefeedID{} }
func (m *ChangefeedID) String() string { return proto.CompactTextString(m) }
func (*ChangefeedID) ProtoMessage()    {}
func (*ChangefeedID) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{39}
}
func (m *ChangefeedID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChangefeedID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ChangefeedID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ChangefeedID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChangefeedID.Merge(m, src)
}
func (m *ChangefeedID) XXX_Size() int {
	return m.Size()
}
func (m *ChangefeedID) XXX_DiscardUnknown() {
	xxx_messageInfo_ChangefeedID.DiscardUnknown(m)
}

var xxx_messageInfo_ChangefeedID proto.InternalMessageInfo

func (m *ChangefeedID) GetHigh() uint64 {
	if m != nil {
		return m.High
	}
	return 0
}

func (m *ChangefeedID) GetLow() uint64 {
	if m != nil {
		return m.Low
	}
	return 0
}

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

func (m *ChangefeedID) GetKeyspace() string {
	if m != nil {
		return m.Keyspace
	}
	return ""
}

type LogCoordinatorResolvedTsRequest struct {
	ChangefeedID *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
}

func (m *LogCoordinatorResolvedTsRequest) Reset()         { *m = LogCoordinatorResolvedTsRequest{} }
func (m *LogCoordinatorResolvedTsRequest) String() string { return proto.CompactTextString(m) }
func (*LogCoordinatorResolvedTsRequest) ProtoMessage()    {}
func (*LogCoordinatorResolvedTsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{40}
}
func (m *LogCoordinatorResolvedTsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogCoordinatorResolvedTsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogCoordinatorResolvedTsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LogCoordinatorResolvedTsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogCoordinatorResolvedTsRequest.Merge(m, src)
}
func (m *LogCoordinatorResolvedTsRequest) XXX_Size() int {
	return m.Size()
}
func (m *LogCoordinatorResolvedTsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LogCoordinatorResolvedTsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LogCoordinatorResolvedTsRequest proto.InternalMessageInfo

func (m *LogCoordinatorResolvedTsRequest) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

type LogCoordinatorResolvedTsResponse struct {
	ChangefeedID *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	ResolvedTs   uint64        `protobuf:"varint,2,opt,name=resolvedTs,proto3" json:"resolvedTs,omitempty"`
}

func (m *LogCoordinatorResolvedTsResponse) Reset()         { *m = LogCoordinatorResolvedTsResponse{} }
func (m *LogCoordinatorResolvedTsResponse) String() string { return proto.CompactTextString(m) }
func (*LogCoordinatorResolvedTsResponse) ProtoMessage()    {}
func (*LogCoordinatorResolvedTsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{41}
}
func (m *LogCoordinatorResolvedTsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogCoordinatorResolvedTsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogCoordinatorResolvedTsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LogCoordinatorResolvedTsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogCoordinatorResolvedTsResponse.Merge(m, src)
}
func (m *LogCoordinatorResolvedTsResponse) XXX_Size() int {
	return m.Size()
}
func (m *LogCoordinatorResolvedTsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LogCoordinatorResolvedTsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LogCoordinatorResolvedTsResponse proto.InternalMessageInfo

func (m *LogCoordinatorResolvedTsResponse) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *LogCoordinatorResolvedTsResponse) GetResolvedTs() uint64 {
	if m != nil {
		return m.ResolvedTs
	}
	return 0
}

type ChecksumMeta struct {
	State ChecksumState `protobuf:"varint,1,opt,name=state,proto3,enum=heartbeatpb.ChecksumState" json:"state,omitempty"`
	// checksumStateSeq is a monotonic version for checksumState,
	// used to discard out-of-order meta info.
	ChecksumStateSeq uint64 `protobuf:"varint,2,opt,name=checksumStateSeq,proto3" json:"checksumStateSeq,omitempty"`
}

func (m *ChecksumMeta) Reset()         { *m = ChecksumMeta{} }
func (m *ChecksumMeta) String() string { return proto.CompactTextString(m) }
func (*ChecksumMeta) ProtoMessage()    {}
func (*ChecksumMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{42}
}
func (m *ChecksumMeta) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChecksumMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ChecksumMeta.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ChecksumMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChecksumMeta.Merge(m, src)
}
func (m *ChecksumMeta) XXX_Size() int {
	return m.Size()
}
func (m *ChecksumMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_ChecksumMeta.DiscardUnknown(m)
}

var xxx_messageInfo_ChecksumMeta proto.InternalMessageInfo

func (m *ChecksumMeta) GetState() ChecksumState {
	if m != nil {
		return m.State
	}
	return ChecksumState_UNINITIALIZED
}

func (m *ChecksumMeta) GetChecksumStateSeq() uint64 {
	if m != nil {
		return m.ChecksumStateSeq
	}
	return 0
}

type DispatcherSetChecksum struct {
	Count   uint64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	XorHigh uint64 `protobuf:"varint,2,opt,name=xorHigh,proto3" json:"xorHigh,omitempty"`
	XorLow  uint64 `protobuf:"varint,3,opt,name=xorLow,proto3" json:"xorLow,omitempty"`
	SumHigh uint64 `protobuf:"varint,4,opt,name=sumHigh,proto3" json:"sumHigh,omitempty"`
	SumLow  uint64 `protobuf:"varint,5,opt,name=sumLow,proto3" json:"sumLow,omitempty"`
}

func (m *DispatcherSetChecksum) Reset()         { *m = DispatcherSetChecksum{} }
func (m *DispatcherSetChecksum) String() string { return proto.CompactTextString(m) }
func (*DispatcherSetChecksum) ProtoMessage()    {}
func (*DispatcherSetChecksum) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{43}
}
func (m *DispatcherSetChecksum) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DispatcherSetChecksum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DispatcherSetChecksum.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DispatcherSetChecksum) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DispatcherSetChecksum.Merge(m, src)
}
func (m *DispatcherSetChecksum) XXX_Size() int {
	return m.Size()
}
func (m *DispatcherSetChecksum) XXX_DiscardUnknown() {
	xxx_messageInfo_DispatcherSetChecksum.DiscardUnknown(m)
}

var xxx_messageInfo_DispatcherSetChecksum proto.InternalMessageInfo

func (m *DispatcherSetChecksum) GetCount() uint64 {
	if m != nil {
		return m.Count
	}
	return 0
}

func (m *DispatcherSetChecksum) GetXorHigh() uint64 {
	if m != nil {
		return m.XorHigh
	}
	return 0
}

func (m *DispatcherSetChecksum) GetXorLow() uint64 {
	if m != nil {
		return m.XorLow
	}
	return 0
}

func (m *DispatcherSetChecksum) GetSumHigh() uint64 {
	if m != nil {
		return m.SumHigh
	}
	return 0
}

func (m *DispatcherSetChecksum) GetSumLow() uint64 {
	if m != nil {
		return m.SumLow
	}
	return 0
}

// DispatcherSetChecksumAckResponse is sent from dispatcherManager to maintainer
// to ack the set checksum request.
type DispatcherSetChecksumAckResponse struct {
	ChangefeedID *ChangefeedID `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	Epoch        uint64        `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Mode         int64         `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
	Seq          uint64        `protobuf:"varint,4,opt,name=seq,proto3" json:"seq,omitempty"`
}

func (m *DispatcherSetChecksumAckResponse) Reset()         { *m = DispatcherSetChecksumAckResponse{} }
func (m *DispatcherSetChecksumAckResponse) String() string { return proto.CompactTextString(m) }
func (*DispatcherSetChecksumAckResponse) ProtoMessage()    {}
func (*DispatcherSetChecksumAckResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{44}
}
func (m *DispatcherSetChecksumAckResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DispatcherSetChecksumAckResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DispatcherSetChecksumAckResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DispatcherSetChecksumAckResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DispatcherSetChecksumAckResponse.Merge(m, src)
}
func (m *DispatcherSetChecksumAckResponse) XXX_Size() int {
	return m.Size()
}
func (m *DispatcherSetChecksumAckResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DispatcherSetChecksumAckResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DispatcherSetChecksumAckResponse proto.InternalMessageInfo

func (m *DispatcherSetChecksumAckResponse) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *DispatcherSetChecksumAckResponse) GetEpoch() uint64 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

func (m *DispatcherSetChecksumAckResponse) GetMode() int64 {
	if m != nil {
		return m.Mode
	}
	return 0
}

func (m *DispatcherSetChecksumAckResponse) GetSeq() uint64 {
	if m != nil {
		return m.Seq
	}
	return 0
}

// DispatcherSetChecksumUpdateRequest is sent from maintainer to dispatcherManager
// to update the set checksum.
type DispatcherSetChecksumUpdateRequest struct {
	ChangefeedID *ChangefeedID          `protobuf:"bytes,1,opt,name=changefeedID,proto3" json:"changefeedID,omitempty"`
	Epoch        uint64                 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Mode         int64                  `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
	Seq          uint64                 `protobuf:"varint,4,opt,name=seq,proto3" json:"seq,omitempty"`
	Checksum     *DispatcherSetChecksum `protobuf:"bytes,5,opt,name=checksum,proto3" json:"checksum,omitempty"`
}

func (m *DispatcherSetChecksumUpdateRequest) Reset()         { *m = DispatcherSetChecksumUpdateRequest{} }
func (m *DispatcherSetChecksumUpdateRequest) String() string { return proto.CompactTextString(m) }
func (*DispatcherSetChecksumUpdateRequest) ProtoMessage()    {}
func (*DispatcherSetChecksumUpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6d584080fdadb670, []int{45}
}
func (m *DispatcherSetChecksumUpdateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DispatcherSetChecksumUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DispatcherSetChecksumUpdateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DispatcherSetChecksumUpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DispatcherSetChecksumUpdateRequest.Merge(m, src)
}
func (m *DispatcherSetChecksumUpdateRequest) XXX_Size() int {
	return m.Size()
}
func (m *DispatcherSetChecksumUpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DispatcherSetChecksumUpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DispatcherSetChecksumUpdateRequest proto.InternalMessageInfo

func (m *DispatcherSetChecksumUpdateRequest) GetChangefeedID() *ChangefeedID {
	if m != nil {
		return m.ChangefeedID
	}
	return nil
}

func (m *DispatcherSetChecksumUpdateRequest) GetEpoch() uint64 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

func (m *DispatcherSetChecksumUpdateRequest) GetMode() int64 {
	if m != nil {
		return m.Mode
	}
	return 0
}

func (m *DispatcherSetChecksumUpdateRequest) GetSeq() uint64 {
	if m != nil {
		return m.Seq
	}
	return 0
}

func (m *DispatcherSetChecksumUpdateRequest) GetChecksum() *DispatcherSetChecksum {
	if m != nil {
		return m.Checksum
	}
	return nil
}

func init() {
	proto.RegisterEnum("heartbeatpb.Action", Action_name, Action_value)
	proto.RegisterEnum("heartbeatpb.ScheduleAction", ScheduleAction_name, ScheduleAction_value)
	proto.RegisterEnum("heartbeatpb.OperatorType", OperatorType_name, OperatorType_value)
	proto.RegisterEnum("heartbeatpb.BlockStage", BlockStage_name, BlockStage_value)
	proto.RegisterEnum("heartbeatpb.InfluenceType", InfluenceType_name, InfluenceType_value)
	proto.RegisterEnum("heartbeatpb.ComponentState", ComponentState_name, ComponentState_value)
	proto.RegisterEnum("heartbeatpb.ChecksumState", ChecksumState_name, ChecksumState_value)
	proto.RegisterType((*TableSpan)(nil), "heartbeatpb.TableSpan")
	proto.RegisterType((*HeartBeatRequest)(nil), "heartbeatpb.HeartBeatRequest")
	proto.RegisterType((*Watermark)(nil), "heartbeatpb.Watermark")
	proto.RegisterType((*DispatcherAction)(nil), "heartbeatpb.DispatcherAction")
	proto.RegisterType((*ACK)(nil), "heartbeatpb.ACK")
	proto.RegisterType((*InfluencedDispatchers)(nil), "heartbeatpb.InfluencedDispatchers")
	proto.RegisterType((*DispatcherStatus)(nil), "heartbeatpb.DispatcherStatus")
	proto.RegisterType((*HeartBeatResponse)(nil), "heartbeatpb.HeartBeatResponse")
	proto.RegisterType((*CheckpointTsMessage)(nil), "heartbeatpb.CheckpointTsMessage")
	proto.RegisterType((*RedoMetaMessage)(nil), "heartbeatpb.RedoMetaMessage")
	proto.RegisterType((*RedoResolvedTsProgressMessage)(nil), "heartbeatpb.RedoResolvedTsProgressMessage")
	proto.RegisterType((*RedoResolvedTsForwardMessage)(nil), "heartbeatpb.RedoResolvedTsForwardMessage")
	proto.RegisterType((*DispatcherConfig)(nil), "heartbeatpb.DispatcherConfig")
	proto.RegisterType((*ScheduleDispatcherRequest)(nil), "heartbeatpb.ScheduleDispatcherRequest")
	proto.RegisterType((*MergeDispatcherRequest)(nil), "heartbeatpb.MergeDispatcherRequest")
	proto.RegisterType((*MaintainerHeartbeat)(nil), "heartbeatpb.MaintainerHeartbeat")
	proto.RegisterType((*MaintainerStatus)(nil), "heartbeatpb.MaintainerStatus")
	proto.RegisterType((*CoordinatorBootstrapRequest)(nil), "heartbeatpb.CoordinatorBootstrapRequest")
	proto.RegisterType((*CoordinatorBootstrapResponse)(nil), "heartbeatpb.CoordinatorBootstrapResponse")
	proto.RegisterType((*AddMaintainerRequest)(nil), "heartbeatpb.AddMaintainerRequest")
	proto.RegisterType((*RemoveMaintainerRequest)(nil), "heartbeatpb.RemoveMaintainerRequest")
	proto.RegisterType((*MaintainerBootstrapRequest)(nil), "heartbeatpb.MaintainerBootstrapRequest")
	proto.RegisterType((*MaintainerBootstrapResponse)(nil), "heartbeatpb.MaintainerBootstrapResponse")
	proto.RegisterType((*MaintainerPostBootstrapRequest)(nil), "heartbeatpb.MaintainerPostBootstrapRequest")
	proto.RegisterType((*MaintainerPostBootstrapResponse)(nil), "heartbeatpb.MaintainerPostBootstrapResponse")
	proto.RegisterType((*SchemaInfo)(nil), "heartbeatpb.SchemaInfo")
	proto.RegisterType((*TableInfo)(nil), "heartbeatpb.TableInfo")
	proto.RegisterType((*BootstrapTableSpan)(nil), "heartbeatpb.BootstrapTableSpan")
	proto.RegisterType((*MaintainerCloseRequest)(nil), "heartbeatpb.MaintainerCloseRequest")
	proto.RegisterType((*MaintainerCloseResponse)(nil), "heartbeatpb.MaintainerCloseResponse")
	proto.RegisterType((*InfluencedTables)(nil), "heartbeatpb.InfluencedTables")
	proto.RegisterType((*Table)(nil), "heartbeatpb.Table")
	proto.RegisterType((*SchemaIDChange)(nil), "heartbeatpb.SchemaIDChange")
	proto.RegisterType((*State)(nil), "heartbeatpb.State")
	proto.RegisterType((*TableSpanBlockStatus)(nil), "heartbeatpb.TableSpanBlockStatus")
	proto.RegisterType((*TableSpanStatus)(nil), "heartbeatpb.TableSpanStatus")
	proto.RegisterType((*BlockStatusRequest)(nil), "heartbeatpb.BlockStatusRequest")
	proto.RegisterType((*RunningError)(nil), "heartbeatpb.RunningError")
	proto.RegisterType((*DispatcherID)(nil), "heartbeatpb.DispatcherID")
	proto.RegisterType((*ChangefeedID)(nil), "heartbeatpb.ChangefeedID")
	proto.RegisterType((*LogCoordinatorResolvedTsRequest)(nil), "heartbeatpb.LogCoordinatorResolvedTsRequest")
	proto.RegisterType((*LogCoordinatorResolvedTsResponse)(nil), "heartbeatpb.LogCoordinatorResolvedTsResponse")
	proto.RegisterType((*ChecksumMeta)(nil), "heartbeatpb.ChecksumMeta")
	proto.RegisterType((*DispatcherSetChecksum)(nil), "heartbeatpb.DispatcherSetChecksum")
	proto.RegisterType((*DispatcherSetChecksumAckResponse)(nil), "heartbeatpb.DispatcherSetChecksumAckResponse")
	proto.RegisterType((*DispatcherSetChecksumUpdateRequest)(nil), "heartbeatpb.DispatcherSetChecksumUpdateRequest")
}

func init() { proto.RegisterFile("heartbeatpb/heartbeat.proto", fileDescriptor_6d584080fdadb670) }

var fileDescriptor_6d584080fdadb670 = []byte{
	// 2452 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5a, 0xcf, 0x6f, 0x1c, 0x49,
	0xf5, 0x77, 0xf7, 0xfc, 0xb0, 0xe7, 0xd9, 0x63, 0x77, 0x2a, 0xbf, 0x9c, 0xc4, 0x71, 0xbc, 0xfd,
	0xfd, 0x82, 0xcc, 0xec, 0x92, 0x90, 0xec, 0x46, 0xc0, 0xb2, 0x6c, 0x18, 0xcf, 0x64, 0x37, 0x23,
	0x67, 0x6c, 0xab, 0xc6, 0xab, 0xc0, 0x72, 0x18, 0xda, 0xdd, 0x95, 0x71, 0xcb, 0x33, 0xdd, 0x9d,
	0xae, 0x9e, 0x38, 0x8e, 0xb4, 0x20, 0x84, 0xb8, 0x71, 0x00, 0x09, 0x0e, 0x1c, 0x38, 0x20, 0xfe,
	0x01, 0x24, 0xc4, 0x11, 0x89, 0x1b, 0x48, 0x5c, 0xf6, 0x84, 0xe0, 0x04, 0x4a, 0xfe, 0x01, 0x04,
	0x07, 0xae, 0xa8, 0x7e, 0xf5, 0xaf, 0x69, 0xdb, 0x89, 0x3c, 0xca, 0xad, 0x5f, 0xd5, 0xe7, 0xbd,
	0x7a, 0xf5, 0xde, 0xab, 0xf7, 0x5e, 0xd5, 0x0c, 0x5c, 0xdb, 0x27, 0x56, 0x18, 0xed, 0x11, 0x2b,
	0x0a, 0xf6, 0x6e, 0xc5, 0xdf, 0x37, 0x83, 0xd0, 0x8f, 0x7c, 0x34, 0x9f, 0x9a, 0x34, 0x8f, 0xa0,
	0xb6, 0x6b, 0xed, 0x0d, 0x49, 0x2f, 0xb0, 0x3c, 0xb4, 0x0c, 0xb3, 0x9c, 0xe8, 0xb4, 0x97, 0xb5,
	0x35, 0x6d, 0xbd, 0x84, 0x15, 0x89, 0xae, 0xc2, 0x5c, 0x2f, 0xb2, 0xc2, 0x68, 0x93, 0x1c, 0x2d,
	0xeb, 0x6b, 0xda, 0xfa, 0x02, 0x8e, 0x69, 0x74, 0x09, 0xaa, 0xf7, 0x3d, 0x87, 0xcd, 0x94, 0xf8,
	0x8c, 0xa4, 0xd0, 0x2a, 0xc0, 0x26, 0x39, 0xa2, 0x81, 0x65, 0x33, 0x81, 0xe5, 0x35, 0x6d, 0xbd,
	0x8e, 0x53, 0x23, 0xe6, 0x5f, 0x75, 0x30, 0x1e, 0x30, 0x55, 0x36, 0x88, 0x15, 0x61, 0xf2, 0x64,
	0x4c, 0x68, 0x84, 0xbe, 0x09, 0x0b, 0xf6, 0xbe, 0xe5, 0x0d, 0xc8, 0x63, 0x42, 0x1c, 0xa9, 0xc7,
	0xfc, 0x9d, 0x2b, 0x37, 0x53, 0x3a, 0xdf, 0x6c, 0xa5, 0x00, 0x38, 0x03, 0x47, 0xef, 0x41, 0xed,
	0xd0, 0x8a, 0x48, 0x38, 0xb2, 0xc2, 0x03, 0xae, 0xe8, 0xfc, 0x9d, 0x4b, 0x19, 0xde, 0x47, 0x6a,
	0x16, 0x27, 0x40, 0xf4, 0x01, 0xd4, 0x43, 0xe2, 0xf8, 0xf1, 0x1c, 0xdf, 0xc8, 0xf1, 0x9c, 0x59,
	0x30, 0xfa, 0x1a, 0xcc, 0xd1, 0xc8, 0x8a, 0xc6, 0x94, 0xd0, 0xe5, 0xf2, 0x5a, 0x69, 0x7d, 0xfe,
	0xce, 0x4a, 0x86, 0x31, 0xb6, 0x6f, 0x8f, 0xa3, 0x70, 0x8c, 0x46, 0xeb, 0xb0, 0x64, 0xfb, 0xa3,
	0x80, 0x0c, 0x49, 0x44, 0xc4, 0xe4, 0x72, 0x65, 0x4d, 0x5b, 0x9f, 0xc3, 0xf9, 0x61, 0xf4, 0x36,
	0x94, 0x48, 0x18, 0x2e, 0x57, 0x0b, 0xac, 0x81, 0xc7, 0x9e, 0xe7, 0x7a, 0x83, 0xfb, 0x61, 0xe8,
	0x87, 0x98, 0xa1, 0xcc, 0x1f, 0x6b, 0x50, 0x4b, 0xd4, 0x33, 0x99, 0x45, 0x89, 0x7d, 0x10, 0xf8,
	0xae, 0x17, 0xed, 0x52, 0x6e, 0xd1, 0x32, 0xce, 0x8c, 0x31, 0x57, 0x85, 0x84, 0xfa, 0xc3, 0xa7,
	0xc4, 0xd9, 0xa5, 0xdc, 0x6e, 0x65, 0x9c, 0x1a, 0x41, 0x06, 0x94, 0x28, 0x79, 0xc2, 0xcd, 0x52,
	0xc6, 0xec, 0x93, 0x49, 0x1d, 0x5a, 0x34, 0xea, 0x1d, 0x79, 0x36, 0xe7, 0x29, 0x0b, 0xa9, 0xe9,
	0x31, 0xf3, 0x33, 0x30, 0xda, 0x2e, 0x0d, 0xac, 0xc8, 0xde, 0x27, 0x61, 0xd3, 0x8e, 0x5c, 0xdf,
	0x43, 0x6f, 0x43, 0xd5, 0xe2, 0x5f, 0x5c, 0x8f, 0xc5, 0x3b, 0xe7, 0x33, 0x7b, 0x11, 0x20, 0x2c,
	0x21, 0x2c, 0xea, 0x5a, 0xfe, 0x68, 0xe4, 0x46, 0xb1, 0x52, 0x31, 0x8d, 0xd6, 0x60, 0xbe, 0x43,
	0xd9, 0x52, 0x3b, 0x6c, 0x0f, 0x5c, 0xb5, 0x39, 0x9c, 0x1e, 0x32, 0x5b, 0x50, 0x6a, 0xb6, 0x36,
	0x33, 0x42, 0xb4, 0x93, 0x85, 0xe8, 0x93, 0x42, 0x7e, 0xa4, 0xc3, 0xc5, 0x8e, 0xf7, 0x78, 0x38,
	0x26, 0x6c, 0x53, 0xc9, 0x76, 0x28, 0xfa, 0x16, 0xd4, 0xe3, 0x89, 0xdd, 0xa3, 0x80, 0xc8, 0x0d,
	0x5d, 0xcd, 0x6c, 0x28, 0x83, 0xc0, 0x59, 0x06, 0x74, 0x0f, 0xea, 0x89, 0xc0, 0x4e, 0x9b, 0xed,
	0xb1, 0x34, 0xe1, 0xde, 0x34, 0x02, 0x67, 0xf1, 0xfc, 0x54, 0xda, 0xfb, 0x64, 0x64, 0x75, 0xda,
	0xdc, 0x00, 0x25, 0x1c, 0xd3, 0x68, 0x13, 0xce, 0x93, 0x67, 0xf6, 0x70, 0xec, 0x90, 0x14, 0x8f,
	0xc3, 0xfd, 0x74, 0xe2, 0x12, 0x45, 0x5c, 0xe6, 0x9f, 0xb4, 0xb4, 0x2b, 0x65, 0x4c, 0x7e, 0x1b,
	0x2e, 0xba, 0x45, 0x96, 0x91, 0x67, 0xd6, 0x2c, 0x36, 0x44, 0x1a, 0x89, 0x8b, 0x05, 0xa0, 0xbb,
	0x71, 0x90, 0x88, 0x23, 0x7c, 0xfd, 0x18, 0x75, 0x73, 0xe1, 0x62, 0x42, 0xc9, 0xb2, 0xd5, 0xe1,
	0x35, 0xb2, 0x81, 0xd5, 0xda, 0xc4, 0x6c, 0xd2, 0xfc, 0xbd, 0x06, 0xe7, 0x52, 0x49, 0x87, 0x06,
	0xbe, 0x47, 0xc9, 0x59, 0xb3, 0x4e, 0x17, 0x90, 0x93, 0xb3, 0x0e, 0x51, 0xde, 0x3c, 0x4e, 0x77,
	0x99, 0x0c, 0x0a, 0x18, 0x11, 0x82, 0xf2, 0xc8, 0x77, 0x88, 0x74, 0x29, 0xff, 0x36, 0x9f, 0xc1,
	0xf9, 0x56, 0xea, 0xc4, 0x76, 0x09, 0xa5, 0xd6, 0xe0, 0xcc, 0x8a, 0xe7, 0x73, 0x83, 0x3e, 0x99,
	0x1b, 0xcc, 0x9f, 0x6b, 0xb0, 0x84, 0x89, 0xe3, 0x77, 0x49, 0x64, 0x4d, 0x69, 0xd9, 0xd3, 0xd2,
	0x4d, 0x5e, 0xad, 0x52, 0x81, 0x5a, 0xdf, 0x87, 0xeb, 0x4c, 0x2b, 0x1c, 0x73, 0xed, 0x84, 0xfe,
	0x20, 0x24, 0x94, 0xbe, 0x19, 0x1d, 0xcd, 0xcf, 0x60, 0x25, 0xbb, 0xfe, 0x47, 0x7e, 0x78, 0x68,
	0x85, 0xce, 0x1b, 0x5a, 0xfe, 0x3f, 0x99, 0x13, 0xd9, 0xf2, 0xbd, 0xc7, 0xee, 0x00, 0x35, 0xa0,
	0x4c, 0x03, 0xcb, 0x93, 0x6b, 0x5d, 0x2a, 0xae, 0x42, 0x98, 0x63, 0x58, 0xad, 0xa7, 0xac, 0x82,
	0xc7, 0xd2, 0x15, 0xc9, 0x34, 0x77, 0x52, 0x19, 0x41, 0x9e, 0xa7, 0x13, 0x52, 0x46, 0x06, 0xce,
	0x92, 0x12, 0x55, 0x49, 0xa9, 0x2c, 0x92, 0x92, 0xa2, 0xe3, 0xc8, 0xae, 0x24, 0x91, 0x8d, 0x1a,
	0x60, 0xd0, 0x03, 0x37, 0x68, 0x77, 0x1f, 0x36, 0x69, 0x4f, 0x6a, 0x54, 0xe5, 0x89, 0x78, 0x62,
	0xdc, 0xfc, 0x85, 0x0e, 0x57, 0x58, 0x86, 0x73, 0xc6, 0xc3, 0x54, 0x82, 0x9a, 0x52, 0xef, 0x70,
	0x17, 0xaa, 0x36, 0xb7, 0xe3, 0x29, 0x59, 0x47, 0x18, 0x1b, 0x4b, 0x30, 0x6a, 0xc1, 0x22, 0x95,
	0x2a, 0x89, 0x7c, 0xc4, 0x0d, 0xb6, 0x78, 0xe7, 0x5a, 0x86, 0xbd, 0x97, 0x81, 0xe0, 0x1c, 0x0b,
	0x53, 0xdd, 0x0f, 0x48, 0x68, 0x45, 0x7e, 0xc8, 0x6b, 0x49, 0x99, 0x8b, 0xc8, 0xaa, 0xbe, 0x9d,
	0x02, 0xe0, 0x0c, 0xdc, 0xfc, 0xaf, 0x06, 0x97, 0xba, 0x24, 0x1c, 0x4c, 0xdf, 0x28, 0xf7, 0xa0,
	0xee, 0xbc, 0x66, 0x8d, 0xca, 0xe0, 0x51, 0x07, 0xd0, 0x88, 0x69, 0xe6, 0xb4, 0x5f, 0x2b, 0xa6,
	0x0a, 0x98, 0xe2, 0xe8, 0x29, 0xa7, 0xf2, 0xe2, 0x0e, 0x9c, 0xef, 0x5a, 0xae, 0x17, 0x59, 0xae,
	0x47, 0xc2, 0x07, 0x4a, 0x1a, 0xfa, 0x7a, 0xaa, 0x27, 0xd3, 0x0a, 0xf2, 0x70, 0xc2, 0x93, 0x6f,
	0xca, 0xcc, 0x3f, 0xea, 0x60, 0xe4, 0xa7, 0xcf, 0x6a, 0xc5, 0xeb, 0x00, 0xec, 0xab, 0xcf, 0x16,
	0x21, 0x3c, 0xbc, 0x6a, 0xb8, 0xc6, 0x46, 0x98, 0x78, 0x82, 0x6e, 0x43, 0x45, 0xcc, 0x14, 0x45,
	0x4e, 0xcb, 0x1f, 0x05, 0xbe, 0x47, 0xbc, 0x88, 0x63, 0xb1, 0x40, 0xa2, 0xff, 0x83, 0x7a, 0x92,
	0x0e, 0xfb, 0x51, 0xdc, 0x80, 0x65, 0xda, 0x3a, 0xd9, 0x35, 0x56, 0x0a, 0x5c, 0x36, 0xd1, 0x35,
	0xa2, 0x2f, 0xc0, 0xe2, 0x9e, 0xef, 0x47, 0x34, 0x0a, 0xad, 0xa0, 0xef, 0xf8, 0x1e, 0x91, 0xa7,
	0xb0, 0x1e, 0x8f, 0xb6, 0x7d, 0x8f, 0x4c, 0x34, 0x7e, 0xb3, 0x05, 0x8d, 0xdf, 0x57, 0xe1, 0x5a,
	0xcb, 0xf7, 0x43, 0xc7, 0xf5, 0x58, 0x84, 0x6e, 0x28, 0x7e, 0x15, 0x92, 0xcb, 0x30, 0xfb, 0x94,
	0x84, 0x54, 0x35, 0x81, 0x25, 0xac, 0x48, 0xf3, 0x3b, 0xb0, 0x52, 0xcc, 0x28, 0xeb, 0xf4, 0x19,
	0xdc, 0xfa, 0x17, 0x0d, 0x2e, 0x34, 0x1d, 0x27, 0x41, 0x28, 0x6d, 0xbe, 0x04, 0xba, 0xeb, 0x9c,
	0xee, 0x50, 0xdd, 0x75, 0xd8, 0x4d, 0x27, 0x95, 0x21, 0x16, 0xe2, 0x14, 0x30, 0xe1, 0x8c, 0x82,
	0x82, 0x85, 0x1a, 0x70, 0xce, 0xa5, 0x7d, 0x8f, 0x1c, 0xf6, 0x93, 0xd0, 0xe0, 0x5e, 0x9b, 0xc3,
	0x4b, 0x2e, 0xdd, 0x22, 0x87, 0xc9, 0x72, 0xe8, 0x06, 0xcc, 0x1f, 0xc8, 0x8b, 0x52, 0xdf, 0x75,
	0x78, 0xba, 0xac, 0x63, 0x50, 0x43, 0x1d, 0xc7, 0xfc, 0xa5, 0x06, 0x97, 0x31, 0x19, 0xf9, 0x4f,
	0xc9, 0x99, 0x36, 0xb4, 0x0c, 0xb3, 0xb6, 0x45, 0x6d, 0xcb, 0x21, 0xb2, 0xf7, 0x55, 0x24, 0x9b,
	0x09, 0xb9, 0x7c, 0x47, 0xb6, 0xd6, 0x8a, 0xcc, 0xeb, 0x56, 0x9e, 0xd0, 0xed, 0x37, 0x25, 0xb8,
	0x9a, 0x68, 0x35, 0xe1, 0xfd, 0x33, 0x1e, 0xa5, 0xe3, 0x7c, 0x70, 0x85, 0x87, 0x46, 0x98, 0x32,
	0x7f, 0x5c, 0xd0, 0x6c, 0x78, 0x2b, 0x62, 0xd5, 0xaf, 0x1f, 0x85, 0xee, 0x60, 0x40, 0xc2, 0x3e,
	0x79, 0x4a, 0xbc, 0xa8, 0x9f, 0xe4, 0x29, 0xb5, 0x8f, 0x13, 0x33, 0xd2, 0x75, 0x2e, 0x63, 0x57,
	0x88, 0xb8, 0xcf, 0x24, 0xa4, 0x5b, 0xe4, 0x62, 0xf7, 0x56, 0x8a, 0xdd, 0x6b, 0xc1, 0x5a, 0x56,
	0x21, 0x76, 0xa1, 0xcc, 0xe9, 0x53, 0x3d, 0x4d, 0x9f, 0x95, 0xb4, 0x3e, 0xac, 0x15, 0xc9, 0xa8,
	0x93, 0xf3, 0xd2, 0xec, 0x84, 0x97, 0xfe, 0xae, 0xc3, 0xb5, 0x42, 0x2f, 0x4d, 0xa7, 0x25, 0xbe,
	0x0b, 0x15, 0xd6, 0x66, 0xa8, 0x7a, 0x71, 0x23, 0xc3, 0x17, 0xaf, 0x96, 0x34, 0x25, 0x02, 0xad,
	0x32, 0x56, 0xe9, 0x55, 0xee, 0xb9, 0xaf, 0x96, 0x03, 0xdf, 0x01, 0xc4, 0xad, 0x9b, 0x45, 0x56,
	0x38, 0xd2, 0x60, 0x33, 0xe9, 0xb6, 0x1a, 0xb5, 0xa1, 0xa6, 0x0a, 0x2b, 0xeb, 0x42, 0x98, 0xea,
	0x5f, 0x2c, 0xac, 0xe3, 0x13, 0x85, 0x16, 0x27, 0x8c, 0xe6, 0xef, 0x74, 0x58, 0x4d, 0x6c, 0xbb,
	0xe3, 0xd3, 0x68, 0xda, 0xa7, 0xe0, 0x95, 0x42, 0x5a, 0x3f, 0x63, 0x48, 0xdf, 0x86, 0x59, 0xd1,
	0xb9, 0xb1, 0x13, 0xc5, 0x4c, 0x71, 0x79, 0xc2, 0x14, 0x23, 0xab, 0xe3, 0x3d, 0xf6, 0xb1, 0xc2,
	0xa1, 0xf7, 0x61, 0x81, 0x5b, 0x5b, 0xf1, 0x95, 0x4f, 0xe6, 0x9b, 0x67, 0x60, 0x41, 0x53, 0xf3,
	0xdf, 0x1a, 0xdc, 0x38, 0xd6, 0x6a, 0xd3, 0x89, 0xca, 0x37, 0x62, 0xb6, 0xd7, 0x89, 0x61, 0xf3,
	0x19, 0x40, 0x62, 0x8f, 0xcc, 0x85, 0x5e, 0xcb, 0x5d, 0xe8, 0x57, 0x15, 0x72, 0xcb, 0x1a, 0xa9,
	0x1e, 0x22, 0x35, 0x82, 0x6e, 0x42, 0x95, 0x1f, 0x27, 0xe5, 0xac, 0x82, 0xf6, 0x9f, 0xdb, 0x5c,
	0xa2, 0xcc, 0x96, 0x7c, 0xf9, 0xe3, 0x0b, 0x1f, 0xff, 0xf2, 0xb7, 0x22, 0x61, 0xa9, 0x55, 0x93,
	0x01, 0xf3, 0x0f, 0x3a, 0xa0, 0xc9, 0xd3, 0xcc, 0x4a, 0xd0, 0x31, 0xce, 0xc9, 0x18, 0x52, 0x97,
	0x2f, 0x8b, 0x6a, 0xcb, 0x7a, 0x6e, 0xcb, 0xea, 0x3e, 0x53, 0x7a, 0x85, 0xfb, 0xcc, 0x47, 0x60,
	0xd8, 0xaa, 0x53, 0xea, 0x8b, 0xaa, 0x2f, 0xbb, 0xe8, 0x13, 0xdb, 0xa9, 0x25, 0x3b, 0x4d, 0x8f,
	0xe9, 0x64, 0x52, 0xa9, 0x14, 0x24, 0x95, 0x77, 0x61, 0x7e, 0x6f, 0xe8, 0xdb, 0x07, 0xb2, 0xa1,
	0x13, 0xb9, 0x1a, 0x65, 0xa3, 0x9c, 0x8b, 0x07, 0x0e, 0x13, 0x5d, 0x9e, 0x6a, 0x5f, 0x67, 0x53,
	0xed, 0xeb, 0x13, 0xb8, 0x94, 0x84, 0x7c, 0x6b, 0xe8, 0x53, 0x32, 0xa5, 0x04, 0x91, 0xaa, 0xdf,
	0x7a, 0xa6, 0x7e, 0x9b, 0x21, 0x5c, 0x9e, 0x58, 0x72, 0x3a, 0xa7, 0x8b, 0x5d, 0x29, 0xc7, 0xb6,
	0x4d, 0x28, 0x55, 0x6b, 0x4a, 0xd2, 0xfc, 0x89, 0x06, 0x46, 0xf2, 0x02, 0x24, 0x02, 0x70, 0x0a,
	0x0f, 0x68, 0x57, 0x61, 0x4e, 0x86, 0xa9, 0xa8, 0x33, 0x25, 0x1c, 0xd3, 0x27, 0xbd, 0x8d, 0x99,
	0xdf, 0x85, 0x0a, 0xc7, 0x9d, 0xf2, 0xe0, 0x7d, 0x5c, 0x58, 0xae, 0x40, 0xad, 0x17, 0x0c, 0x5d,
	0x9e, 0x05, 0x64, 0x77, 0x94, 0x0c, 0x98, 0x1e, 0x2c, 0x2a, 0xa4, 0xb0, 0xd5, 0x09, 0xab, 0xac,
	0xc1, 0xfc, 0xf6, 0xd0, 0xc9, 0x2d, 0x94, 0x1e, 0x62, 0x88, 0x2d, 0x72, 0x98, 0xdb, 0x49, 0x7a,
	0xc8, 0xfc, 0x75, 0x09, 0x2a, 0x22, 0xc0, 0x56, 0xa0, 0xd6, 0xa1, 0x1b, 0x2c, 0xe0, 0x88, 0xe8,
	0xff, 0xe6, 0x70, 0x32, 0xc0, 0xb4, 0xe0, 0x9f, 0xc9, 0x85, 0x5f, 0x92, 0xe8, 0x1e, 0xcc, 0x8b,
	0x4f, 0x95, 0x3e, 0x26, 0x6f, 0xbf, 0x79, 0xe7, 0xe1, 0x34, 0x07, 0xda, 0x84, 0x73, 0x5b, 0x84,
	0x38, 0xed, 0xd0, 0x0f, 0x02, 0x85, 0x90, 0x0d, 0xd5, 0x29, 0x62, 0x26, 0xf9, 0xd0, 0x07, 0xb0,
	0xc4, 0x06, 0x9b, 0x8e, 0x13, 0x8b, 0x12, 0x17, 0x18, 0x34, 0x79, 0xfe, 0x71, 0x1e, 0xca, 0x6e,
	0xe3, 0x9f, 0x04, 0x8e, 0x15, 0x11, 0x69, 0x42, 0x55, 0xc5, 0xaf, 0x15, 0x95, 0x20, 0xe9, 0x20,
	0x9c, 0x63, 0xc9, 0x3f, 0x0b, 0xcf, 0x4e, 0x3c, 0x0b, 0xa3, 0x2f, 0xf3, 0x1b, 0xdb, 0x80, 0x2c,
	0xcf, 0xf1, 0x98, 0xcd, 0x16, 0xb8, 0x0d, 0x79, 0xe6, 0x07, 0xe2, 0xb6, 0x36, 0x20, 0xe6, 0x0f,
	0xe0, 0x42, 0x9c, 0xaf, 0xd4, 0x2c, 0x4b, 0x36, 0xaf, 0x91, 0x27, 0xd7, 0xd5, 0x1d, 0x51, 0x3f,
	0x36, 0xd9, 0xc8, 0xab, 0x61, 0xd1, 0xf3, 0xe1, 0xbf, 0x34, 0x58, 0xca, 0xfd, 0x0e, 0xf1, 0x3a,
	0x8b, 0x17, 0x25, 0x57, 0x7d, 0x1a, 0xc9, 0xb5, 0xe8, 0xa2, 0x74, 0x1b, 0x2e, 0x8a, 0xb2, 0x4c,
	0xdd, 0xe7, 0xa4, 0x1f, 0x90, 0xb0, 0x4f, 0x89, 0xed, 0x7b, 0xa2, 0x45, 0xd7, 0x31, 0xe2, 0x93,
	0x3d, 0xf7, 0x39, 0xd9, 0x21, 0x61, 0x8f, 0xcf, 0x14, 0xbd, 0x2b, 0x99, 0xbf, 0xd5, 0x00, 0xa5,
	0x6c, 0x3d, 0xa5, 0xbc, 0xfa, 0x31, 0xd4, 0xf7, 0x12, 0xa1, 0xf1, 0x2b, 0xef, 0x5b, 0xc5, 0xb5,
	0x29, 0xbd, 0x7e, 0x96, 0xaf, 0xd0, 0x4b, 0x0e, 0x2c, 0xa4, 0x3b, 0x04, 0x86, 0x89, 0xdc, 0x91,
	0x48, 0x8c, 0x35, 0xcc, 0xbf, 0xd9, 0x98, 0xe7, 0x3b, 0xaa, 0x14, 0xf3, 0x6f, 0x36, 0x66, 0x2b,
	0x59, 0x35, 0xcc, 0xbf, 0xd9, 0x71, 0x1f, 0x89, 0xa7, 0x48, 0x6e, 0xb7, 0x1a, 0x56, 0xa4, 0xf9,
	0x1e, 0x2c, 0xe4, 0x9f, 0x55, 0xf6, 0xdd, 0xc1, 0xbe, 0xfc, 0x71, 0x84, 0x7f, 0x23, 0x03, 0x4a,
	0x43, 0xff, 0x50, 0x26, 0x0a, 0xf6, 0xc9, 0x74, 0x4b, 0x9b, 0xe5, 0xd5, 0xb8, 0xb8, 0xb6, 0xac,
	0x71, 0x90, 0x9a, 0xb1, 0x6f, 0x96, 0x5a, 0xd5, 0x3d, 0x44, 0xaa, 0x16, 0xd3, 0xe6, 0xf7, 0xe0,
	0xc6, 0x43, 0x7f, 0x90, 0x7a, 0x03, 0x48, 0xde, 0x57, 0xa7, 0xe3, 0x40, 0xf3, 0x87, 0x1a, 0xac,
	0x1d, 0xbf, 0xc4, 0x74, 0x0a, 0xe1, 0x69, 0x8f, 0xb7, 0x43, 0x66, 0x4b, 0x62, 0x1f, 0xd0, 0xf1,
	0xa8, 0x4b, 0x22, 0x0b, 0x7d, 0x45, 0x9d, 0xed, 0xa2, 0x0a, 0xa8, 0x90, 0x99, 0x33, 0xde, 0x00,
	0xc3, 0x4e, 0x8f, 0xf7, 0xc8, 0x13, 0xb9, 0xce, 0xc4, 0xb8, 0xf9, 0x33, 0x0d, 0x2e, 0xa6, 0x7e,
	0x77, 0x20, 0x91, 0x92, 0x88, 0x2e, 0x40, 0xc5, 0xf6, 0xc7, 0x5e, 0x24, 0x9d, 0x28, 0x08, 0x16,
	0x39, 0xcf, 0xfc, 0xf0, 0x01, 0x73, 0xae, 0x2c, 0x14, 0x92, 0x64, 0x77, 0xef, 0x67, 0x7e, 0xf8,
	0xd0, 0x3f, 0x94, 0xe7, 0x56, 0x52, 0xa2, 0xf0, 0x8f, 0x38, 0x47, 0x59, 0x5e, 0xbd, 0x05, 0xc9,
	0x38, 0xe8, 0x78, 0xc4, 0x38, 0x44, 0x1b, 0x25, 0x29, 0xf3, 0x57, 0x1a, 0xac, 0x15, 0xea, 0xd4,
	0xb4, 0x0f, 0xa6, 0xe5, 0x85, 0x0b, 0x50, 0x21, 0x81, 0x6f, 0xab, 0x5d, 0x08, 0xa2, 0xe8, 0xdc,
	0xa9, 0x9f, 0x37, 0xcb, 0xf1, 0xcf, 0x9b, 0xe6, 0x3f, 0x34, 0x30, 0x0b, 0xf5, 0x13, 0x95, 0x62,
	0x4a, 0xc9, 0xe4, 0x0c, 0x1a, 0xa2, 0x0f, 0x61, 0x4e, 0x79, 0x9a, 0xdb, 0x36, 0xff, 0x83, 0x5b,
	0xa1, 0xf6, 0x38, 0xe6, 0x69, 0x5c, 0x87, 0xaa, 0x7c, 0x7b, 0xae, 0x41, 0xe5, 0x51, 0xe8, 0x46,
	0xc4, 0x98, 0x41, 0x73, 0x50, 0xde, 0xb1, 0x28, 0x35, 0xb4, 0xc6, 0xba, 0xe8, 0x62, 0x52, 0x4f,
	0xd4, 0x00, 0xd5, 0x56, 0x48, 0x2c, 0x8e, 0x03, 0xa8, 0x8a, 0xd7, 0x27, 0x43, 0x6b, 0x74, 0x61,
	0x21, 0xfd, 0x32, 0xcd, 0xc4, 0x6d, 0xf7, 0x9b, 0x8e, 0x63, 0xcc, 0xa0, 0x05, 0x98, 0xdb, 0xee,
	0x2b, 0x20, 0x63, 0xda, 0xee, 0x77, 0xd9, 0xb7, 0x8e, 0xe6, 0x61, 0x76, 0xbb, 0xcf, 0x7b, 0x26,
	0xa3, 0x24, 0x08, 0xfe, 0x7c, 0x6d, 0x94, 0x1b, 0xef, 0x03, 0x24, 0xf5, 0x93, 0x29, 0xb4, 0xb5,
	0xbd, 0x75, 0xdf, 0x98, 0x61, 0xa0, 0x47, 0xcd, 0xce, 0x6e, 0x67, 0xeb, 0x63, 0x43, 0xe3, 0x04,
	0x16, 0x84, 0xce, 0x30, 0x6d, 0x86, 0x29, 0x35, 0xde, 0xc9, 0x75, 0x94, 0x68, 0x16, 0x4a, 0xcd,
	0xe1, 0xd0, 0x98, 0x41, 0x55, 0xd0, 0xdb, 0x1b, 0x42, 0x87, 0x2d, 0x3f, 0x1c, 0x59, 0x43, 0x43,
	0x6f, 0x3c, 0x87, 0xc5, 0x6c, 0xbd, 0xe2, 0x62, 0xfd, 0xf0, 0xc0, 0xf5, 0x06, 0x62, 0xc1, 0x5e,
	0xc4, 0x1b, 0x13, 0xb1, 0xa0, 0xd8, 0x87, 0x63, 0xe8, 0xc8, 0x80, 0x85, 0x8e, 0xe7, 0x46, 0xae,
	0x35, 0x74, 0x9f, 0x33, 0x6c, 0x09, 0xd5, 0xa1, 0xb6, 0x13, 0x92, 0xc0, 0x0a, 0x19, 0x59, 0x46,
	0x8b, 0x00, 0x7c, 0x3b, 0x98, 0x58, 0xce, 0x91, 0x51, 0x61, 0x0c, 0x8f, 0x2c, 0x37, 0x72, 0xbd,
	0x81, 0xd8, 0x65, 0xb5, 0xf1, 0x0d, 0xa8, 0x67, 0xce, 0x35, 0x3a, 0x07, 0xf5, 0x4f, 0xb6, 0x3a,
	0x5b, 0x9d, 0xdd, 0x4e, 0xf3, 0x61, 0xe7, 0xd3, 0xfb, 0x6d, 0x61, 0xbd, 0x6e, 0xa7, 0xd7, 0x6d,
	0xee, 0xb6, 0x1e, 0x18, 0x1a, 0x33, 0xab, 0xf8, 0xd4, 0x37, 0x3e, 0xfc, 0xf3, 0x8b, 0x55, 0xed,
	0xf3, 0x17, 0xab, 0xda, 0x3f, 0x5f, 0xac, 0x6a, 0x3f, 0x7d, 0xb9, 0x3a, 0xf3, 0xf9, 0xcb, 0xd5,
	0x99, 0xbf, 0xbd, 0x5c, 0x9d, 0xf9, 0xf4, 0xff, 0x07, 0x6e, 0xb4, 0x3f, 0xde, 0xbb, 0x69, 0xfb,
	0xa3, 0x5b, 0x81, 0xeb, 0x0d, 0x6c, 0x2b, 0xb8, 0x15, 0xb9, 0xb6, 0x63, 0xdf, 0x4a, 0x85, 0xc6,
	0x5e, 0x95, 0xff, 0x0f, 0xe4, 0xdd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x37, 0x8b, 0xbe, 0xd7,
	0x26, 0x22, 0x00, 0x00,
}

func (m *TableSpan) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TableSpan) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TableSpan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.KeyspaceID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.KeyspaceID))
		i--
		dAtA[i] = 0x20
	}
	if len(m.EndKey) > 0 {
		i -= len(m.EndKey)
		copy(dAtA[i:], m.EndKey)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.EndKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.StartKey) > 0 {
		i -= len(m.StartKey)
		copy(dAtA[i:], m.StartKey)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.StartKey)))
		i--
		dAtA[i] = 0x12
	}
	if m.TableID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.TableID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *HeartBeatRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HeartBeatRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HeartBeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		{
			size, err := m.Err.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.CompeleteStatus {
		i--
		if m.CompeleteStatus {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.Statuses) > 0 {
		for iNdEx := len(m.Statuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Statuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.RedoWatermark != nil {
		{
			size, err := m.RedoWatermark.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Watermark != nil {
		{
			size, err := m.Watermark.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Watermark) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Watermark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Watermark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LastSyncedTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.LastSyncedTs))
		i--
		dAtA[i] = 0x20
	}
	if m.Seq != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Seq))
		i--
		dAtA[i] = 0x18
	}
	if m.ResolvedTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ResolvedTs))
		i--
		dAtA[i] = 0x10
	}
	if m.CheckpointTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CheckpointTs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DispatcherAction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DispatcherAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DispatcherAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsSyncPoint {
		i--
		if m.IsSyncPoint {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.CommitTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CommitTs))
		i--
		dAtA[i] = 0x10
	}
	if m.Action != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Action))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ACK) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ACK) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ACK) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsSyncPoint {
		i--
		if m.IsSyncPoint {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.CommitTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CommitTs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *InfluencedDispatchers) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InfluencedDispatchers) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InfluencedDispatchers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExcludeDispatcherId != nil {
		{
			size, err := m.ExcludeDispatcherId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.SchemaID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.SchemaID))
		i--
		dAtA[i] = 0x18
	}
	if len(m.DispatcherIDs) > 0 {
		for iNdEx := len(m.DispatcherIDs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DispatcherIDs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.InfluenceType != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.InfluenceType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DispatcherStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DispatcherStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DispatcherStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Ack != nil {
		{
			size, err := m.Ack.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Action != nil {
		{
			size, err := m.Action.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.InfluencedDispatchers != nil {
		{
			size, err := m.InfluencedDispatchers.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *HeartBeatResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HeartBeatResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HeartBeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x18
	}
	if len(m.DispatcherStatuses) > 0 {
		for iNdEx := len(m.DispatcherStatuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DispatcherStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CheckpointTsMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CheckpointTsMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CheckpointTsMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CheckpointTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CheckpointTs))
		i--
		dAtA[i] = 0x10
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RedoMetaMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RedoMetaMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RedoMetaMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CheckpointTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CheckpointTs))
		i--
		dAtA[i] = 0x18
	}
	if m.ResolvedTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ResolvedTs))
		i--
		dAtA[i] = 0x10
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RedoResolvedTsProgressMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RedoResolvedTsProgressMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RedoResolvedTsProgressMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ResolvedTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ResolvedTs))
		i--
		dAtA[i] = 0x10
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RedoResolvedTsForwardMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RedoResolvedTsForwardMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RedoResolvedTsForwardMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ResolvedTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ResolvedTs))
		i--
		dAtA[i] = 0x10
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DispatcherConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DispatcherConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DispatcherConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SkipDMLAsStartTs {
		i--
		if m.SkipDMLAsStartTs {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Mode != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x28
	}
	if m.SchemaID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.SchemaID))
		i--
		dAtA[i] = 0x20
	}
	if m.DispatcherID != nil {
		{
			size, err := m.DispatcherID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.StartTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.StartTs))
		i--
		dAtA[i] = 0x10
	}
	if m.Span != nil {
		{
			size, err := m.Span.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ScheduleDispatcherRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ScheduleDispatcherRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScheduleDispatcherRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OperatorType != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.OperatorType))
		i--
		dAtA[i] = 0x20
	}
	if m.ScheduleAction != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ScheduleAction))
		i--
		dAtA[i] = 0x18
	}
	if m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MergeDispatcherRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MergeDispatcherRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MergeDispatcherRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x20
	}
	if m.MergedDispatcherID != nil {
		{
			size, err := m.MergedDispatcherID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DispatcherIDs) > 0 {
		for iNdEx := len(m.DispatcherIDs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DispatcherIDs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MaintainerHeartbeat) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MaintainerHeartbeat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MaintainerHeartbeat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Statuses) > 0 {
		for iNdEx := len(m.Statuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Statuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *MaintainerStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MaintainerStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MaintainerStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LastSyncedTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.LastSyncedTs))
		i--
		dAtA[i] = 0x38
	}
	if m.BootstrapDone {
		i--
		if m.BootstrapDone {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if len(m.Err) > 0 {
		for iNdEx := len(m.Err) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Err[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.CheckpointTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CheckpointTs))
		i--
		dAtA[i] = 0x20
	}
	if m.State != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	if len(m.FeedState) > 0 {
		i -= len(m.FeedState)
		copy(dAtA[i:], m.FeedState)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.FeedState)))
		i--
		dAtA[i] = 0x12
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CoordinatorBootstrapRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CoordinatorBootstrapRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CoordinatorBootstrapRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Version != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CoordinatorBootstrapResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CoordinatorBootstrapResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CoordinatorBootstrapResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Statuses) > 0 {
		for iNdEx := len(m.Statuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Statuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *AddMaintainerRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddMaintainerRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddMaintainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.KeyspaceId != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.KeyspaceId))
		i--
		dAtA[i] = 0x28
	}
	if m.IsNewChangefeed {
		i--
		if m.IsNewChangefeed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.CheckpointTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CheckpointTs))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Config) > 0 {
		i -= len(m.Config)
		copy(dAtA[i:], m.Config)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Config)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != nil {
		{
			size, err := m.Id.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveMaintainerRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RemoveMaintainerRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveMaintainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.KeyspaceId != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.KeyspaceId))
		i--
		dAtA[i] = 0x20
	}
	if m.Removed {
		i--
		if m.Removed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Cascade {
		i--
		if m.Cascade {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Id != nil {
		{
			size, err := m.Id.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MaintainerBootstrapRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MaintainerBootstrapRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MaintainerBootstrapRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.KeyspaceId != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.KeyspaceId))
		i--
		dAtA[i] = 0x38
	}
	if m.TableTriggerRedoDispatcherId != nil {
		{
			size, err := m.TableTriggerRedoDispatcherId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.IsNewChangefeed {
		i--
		if m.IsNewChangefeed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.TableTriggerEventDispatcherId != nil {
		{
			size, err := m.TableTriggerEventDispatcherId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.StartTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.StartTs))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Config) > 0 {
		i -= len(m.Config)
		copy(dAtA[i:], m.Config)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Config)))
		i--
		dAtA[i] = 0x12
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MaintainerBootstrapResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MaintainerBootstrapResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MaintainerBootstrapResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Operators) > 0 {
		for iNdEx := len(m.Operators) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Operators[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.RedoCheckpointTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.RedoCheckpointTs))
		i--
		dAtA[i] = 0x28
	}
	if m.CheckpointTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CheckpointTs))
		i--
		dAtA[i] = 0x20
	}
	if m.Err != nil {
		{
			size, err := m.Err.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Spans) > 0 {
		for iNdEx := len(m.Spans) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Spans[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MaintainerPostBootstrapRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MaintainerPostBootstrapRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MaintainerPostBootstrapRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RedoSchemas) > 0 {
		for iNdEx := len(m.RedoSchemas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RedoSchemas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Schemas) > 0 {
		for iNdEx := len(m.Schemas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Schemas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.TableTriggerEventDispatcherId != nil {
		{
			size, err := m.TableTriggerEventDispatcherId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MaintainerPostBootstrapResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MaintainerPostBootstrapResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MaintainerPostBootstrapResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		{
			size, err := m.Err.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.TableTriggerEventDispatcherId != nil {
		{
			size, err := m.TableTriggerEventDispatcherId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SchemaInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SchemaInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SchemaInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Tables) > 0 {
		for iNdEx := len(m.Tables) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tables[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.SchemaName) > 0 {
		i -= len(m.SchemaName)
		copy(dAtA[i:], m.SchemaName)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.SchemaName)))
		i--
		dAtA[i] = 0x12
	}
	if m.SchemaID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.SchemaID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TableInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TableInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TableInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TableName) > 0 {
		i -= len(m.TableName)
		copy(dAtA[i:], m.TableName)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.TableName)))
		i--
		dAtA[i] = 0x12
	}
	if m.TableID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.TableID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BootstrapTableSpan) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BootstrapTableSpan) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BootstrapTableSpan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x38
	}
	if m.BlockState != nil {
		{
			size, err := m.BlockState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.CheckpointTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CheckpointTs))
		i--
		dAtA[i] = 0x28
	}
	if m.ComponentStatus != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ComponentStatus))
		i--
		dAtA[i] = 0x20
	}
	if m.Span != nil {
		{
			size, err := m.Span.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.SchemaID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.SchemaID))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MaintainerCloseRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MaintainerCloseRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MaintainerCloseRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Removed {
		i--
		if m.Removed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MaintainerCloseResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MaintainerCloseResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MaintainerCloseResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Success {
		i--
		if m.Success {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *InfluencedTables) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InfluencedTables) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InfluencedTables) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SchemaID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.SchemaID))
		i--
		dAtA[i] = 0x18
	}
	if len(m.TableIDs) > 0 {
		dAtA39 := make([]byte, len(m.TableIDs)*10)
		var j38 int
		for _, num1 := range m.TableIDs {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA39[j38] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j38++
			}
			dAtA39[j38] = uint8(num)
			j38++
		}
		i -= j38
		copy(dAtA[i:], dAtA39[:j38])
		i = encodeVarintHeartbeat(dAtA, i, uint64(j38))
		i--
		dAtA[i] = 0x12
	}
	if m.InfluenceType != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.InfluenceType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Table) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Table) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Table) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Splitable {
		i--
		if m.Splitable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.SchemaID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.SchemaID))
		i--
		dAtA[i] = 0x10
	}
	if m.TableID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.TableID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SchemaIDChange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SchemaIDChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SchemaIDChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NewSchemaID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.NewSchemaID))
		i--
		dAtA[i] = 0x18
	}
	if m.OldSchemaID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.OldSchemaID))
		i--
		dAtA[i] = 0x10
	}
	if m.TableID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.TableID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *State) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *State) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Stage != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Stage))
		i--
		dAtA[i] = 0x40
	}
	if m.IsSyncPoint {
		i--
		if m.IsSyncPoint {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if len(m.UpdatedSchemas) > 0 {
		for iNdEx := len(m.UpdatedSchemas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UpdatedSchemas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.NeedAddedTables) > 0 {
		for iNdEx := len(m.NeedAddedTables) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NeedAddedTables[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.NeedDroppedTables != nil {
		{
			size, err := m.NeedDroppedTables.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.BlockTables != nil {
		{
			size, err := m.BlockTables.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.BlockTs))
		i--
		dAtA[i] = 0x10
	}
	if m.IsBlocked {
		i--
		if m.IsBlocked {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TableSpanBlockStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TableSpanBlockStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TableSpanBlockStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x18
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TableSpanStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TableSpanStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TableSpanStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x28
	}
	if m.EventSizePerSecond != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.EventSizePerSecond))))
		i--
		dAtA[i] = 0x25
	}
	if m.CheckpointTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.CheckpointTs))
		i--
		dAtA[i] = 0x18
	}
	if m.ComponentStatus != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ComponentStatus))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockStatusRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BlockStatusRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockStatuses) > 0 {
		for iNdEx := len(m.BlockStatuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BlockStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHeartbeat(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RunningError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RunningError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RunningError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Code) > 0 {
		i -= len(m.Code)
		copy(dAtA[i:], m.Code)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Code)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Node) > 0 {
		i -= len(m.Node)
		copy(dAtA[i:], m.Node)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Node)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Time) > 0 {
		i -= len(m.Time)
		copy(dAtA[i:], m.Time)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Time)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DispatcherID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DispatcherID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DispatcherID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Low != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Low))
		i--
		dAtA[i] = 0x10
	}
	if m.High != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.High))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ChangefeedID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ChangefeedID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangefeedID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Keyspace) > 0 {
		i -= len(m.Keyspace)
		copy(dAtA[i:], m.Keyspace)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Keyspace)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Low != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Low))
		i--
		dAtA[i] = 0x10
	}
	if m.High != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.High))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LogCoordinatorResolvedTsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LogCoordinatorResolvedTsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogCoordinatorResolvedTsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LogCoordinatorResolvedTsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LogCoordinatorResolvedTsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogCoordinatorResolvedTsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ResolvedTs != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ResolvedTs))
		i--
		dAtA[i] = 0x10
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ChecksumMeta) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ChecksumMeta) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChecksumMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ChecksumStateSeq != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ChecksumStateSeq))
		i--
		dAtA[i] = 0x10
	}
	if m.State != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DispatcherSetChecksum) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DispatcherSetChecksum) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DispatcherSetChecksum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SumLow != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.SumLow))
		i--
		dAtA[i] = 0x28
	}
	if m.SumHigh != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.SumHigh))
		i--
		dAtA[i] = 0x20
	}
	if m.XorLow != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.XorLow))
		i--
		dAtA[i] = 0x18
	}
	if m.XorHigh != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.XorHigh))
		i--
		dAtA[i] = 0x10
	}
	if m.Count != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Count))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DispatcherSetChecksumAckResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DispatcherSetChecksumAckResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DispatcherSetChecksumAckResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Seq != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Seq))
		i--
		dAtA[i] = 0x20
	}
	if m.Mode != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x18
	}
	if m.Epoch != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Epoch))
		i--
		dAtA[i] = 0x10
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DispatcherSetChecksumUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DispatcherSetChecksumUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DispatcherSetChecksumUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Checksum != nil {
		{
			size, err := m.Checksum.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Seq != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Seq))
		i--
		dAtA[i] = 0x20
	}
	if m.Mode != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x18
	}
	if m.Epoch != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Epoch))
		i--
		dAtA[i] = 0x10
	}
	if m.ChangefeedID != nil {
		{
			size, err := m.ChangefeedID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHeartbeat(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintHeartbeat(dAtA []byte, offset int, v uint64) int {
	offset -= sovHeartbeat(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TableSpan) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TableID != 0 {
		n += 1 + sovHeartbeat(uint64(m.TableID))
	}
	l = len(m.StartKey)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.EndKey)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.KeyspaceID != 0 {
		n += 1 + sovHeartbeat(uint64(m.KeyspaceID))
	}
	return n
}

func (m *HeartBeatRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Watermark != nil {
		l = m.Watermark.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.RedoWatermark != nil {
		l = m.RedoWatermark.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if len(m.Statuses) > 0 {
		for _, e := range m.Statuses {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if m.CompeleteStatus {
		n += 2
	}
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func (m *Watermark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CheckpointTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CheckpointTs))
	}
	if m.ResolvedTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.ResolvedTs))
	}
	if m.Seq != 0 {
		n += 1 + sovHeartbeat(uint64(m.Seq))
	}
	if m.LastSyncedTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.LastSyncedTs))
	}
	return n
}

func (m *DispatcherAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Action != 0 {
		n += 1 + sovHeartbeat(uint64(m.Action))
	}
	if m.CommitTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CommitTs))
	}
	if m.IsSyncPoint {
		n += 2
	}
	return n
}

func (m *ACK) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CommitTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CommitTs))
	}
	if m.IsSyncPoint {
		n += 2
	}
	return n
}

func (m *InfluencedDispatchers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.InfluenceType != 0 {
		n += 1 + sovHeartbeat(uint64(m.InfluenceType))
	}
	if len(m.DispatcherIDs) > 0 {
		for _, e := range m.DispatcherIDs {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if m.SchemaID != 0 {
		n += 1 + sovHeartbeat(uint64(m.SchemaID))
	}
	if m.ExcludeDispatcherId != nil {
		l = m.ExcludeDispatcherId.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func (m *DispatcherStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.InfluencedDispatchers != nil {
		l = m.InfluencedDispatchers.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Action != nil {
		l = m.Action.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Ack != nil {
		l = m.Ack.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func (m *HeartBeatResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if len(m.DispatcherStatuses) > 0 {
		for _, e := range m.DispatcherStatuses {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if m.Mode != 0 {
		n += 1 + sovHeartbeat(uint64(m.Mode))
	}
	return n
}

func (m *CheckpointTsMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.CheckpointTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CheckpointTs))
	}
	return n
}

func (m *RedoMetaMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.ResolvedTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.ResolvedTs))
	}
	if m.CheckpointTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CheckpointTs))
	}
	return n
}

func (m *RedoResolvedTsProgressMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.ResolvedTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.ResolvedTs))
	}
	return n
}

func (m *RedoResolvedTsForwardMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.ResolvedTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.ResolvedTs))
	}
	return n
}

func (m *DispatcherConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Span != nil {
		l = m.Span.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.StartTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.StartTs))
	}
	if m.DispatcherID != nil {
		l = m.DispatcherID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.SchemaID != 0 {
		n += 1 + sovHeartbeat(uint64(m.SchemaID))
	}
	if m.Mode != 0 {
		n += 1 + sovHeartbeat(uint64(m.Mode))
	}
	if m.SkipDMLAsStartTs {
		n += 2
	}
	return n
}

func (m *ScheduleDispatcherRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.ScheduleAction != 0 {
		n += 1 + sovHeartbeat(uint64(m.ScheduleAction))
	}
	if m.OperatorType != 0 {
		n += 1 + sovHeartbeat(uint64(m.OperatorType))
	}
	return n
}

func (m *MergeDispatcherRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if len(m.DispatcherIDs) > 0 {
		for _, e := range m.DispatcherIDs {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if m.MergedDispatcherID != nil {
		l = m.MergedDispatcherID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovHeartbeat(uint64(m.Mode))
	}
	return n
}

func (m *MaintainerHeartbeat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Statuses) > 0 {
		for _, e := range m.Statuses {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	return n
}

func (m *MaintainerStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.FeedState)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovHeartbeat(uint64(m.State))
	}
	if m.CheckpointTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CheckpointTs))
	}
	if len(m.Err) > 0 {
		for _, e := range m.Err {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if m.BootstrapDone {
		n += 2
	}
	if m.LastSyncedTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.LastSyncedTs))
	}
	return n
}

func (m *CoordinatorBootstrapRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Version != 0 {
		n += 1 + sovHeartbeat(uint64(m.Version))
	}
	return n
}

func (m *CoordinatorBootstrapResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Statuses) > 0 {
		for _, e := range m.Statuses {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	return n
}

func (m *AddMaintainerRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Config)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.CheckpointTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CheckpointTs))
	}
	if m.IsNewChangefeed {
		n += 2
	}
	if m.KeyspaceId != 0 {
		n += 1 + sovHeartbeat(uint64(m.KeyspaceId))
	}
	return n
}

func (m *RemoveMaintainerRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Cascade {
		n += 2
	}
	if m.Removed {
		n += 2
	}
	if m.KeyspaceId != 0 {
		n += 1 + sovHeartbeat(uint64(m.KeyspaceId))
	}
	return n
}

func (m *MaintainerBootstrapRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Config)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.StartTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.StartTs))
	}
	if m.TableTriggerEventDispatcherId != nil {
		l = m.TableTriggerEventDispatcherId.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.IsNewChangefeed {
		n += 2
	}
	if m.TableTriggerRedoDispatcherId != nil {
		l = m.TableTriggerRedoDispatcherId.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.KeyspaceId != 0 {
		n += 1 + sovHeartbeat(uint64(m.KeyspaceId))
	}
	return n
}

func (m *MaintainerBootstrapResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if len(m.Spans) > 0 {
		for _, e := range m.Spans {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.CheckpointTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CheckpointTs))
	}
	if m.RedoCheckpointTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.RedoCheckpointTs))
	}
	if len(m.Operators) > 0 {
		for _, e := range m.Operators {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	return n
}

func (m *MaintainerPostBootstrapRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.TableTriggerEventDispatcherId != nil {
		l = m.TableTriggerEventDispatcherId.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if len(m.Schemas) > 0 {
		for _, e := range m.Schemas {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if len(m.RedoSchemas) > 0 {
		for _, e := range m.RedoSchemas {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	return n
}

func (m *MaintainerPostBootstrapResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.TableTriggerEventDispatcherId != nil {
		l = m.TableTriggerEventDispatcherId.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func (m *SchemaInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SchemaID != 0 {
		n += 1 + sovHeartbeat(uint64(m.SchemaID))
	}
	l = len(m.SchemaName)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if len(m.Tables) > 0 {
		for _, e := range m.Tables {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	return n
}

func (m *TableInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TableID != 0 {
		n += 1 + sovHeartbeat(uint64(m.TableID))
	}
	l = len(m.TableName)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func (m *BootstrapTableSpan) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.SchemaID != 0 {
		n += 1 + sovHeartbeat(uint64(m.SchemaID))
	}
	if m.Span != nil {
		l = m.Span.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.ComponentStatus != 0 {
		n += 1 + sovHeartbeat(uint64(m.ComponentStatus))
	}
	if m.CheckpointTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CheckpointTs))
	}
	if m.BlockState != nil {
		l = m.BlockState.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovHeartbeat(uint64(m.Mode))
	}
	return n
}

func (m *MaintainerCloseRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Removed {
		n += 2
	}
	return n
}

func (m *MaintainerCloseResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Success {
		n += 2
	}
	return n
}

func (m *InfluencedTables) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.InfluenceType != 0 {
		n += 1 + sovHeartbeat(uint64(m.InfluenceType))
	}
	if len(m.TableIDs) > 0 {
		l = 0
		for _, e := range m.TableIDs {
			l += sovHeartbeat(uint64(e))
		}
		n += 1 + sovHeartbeat(uint64(l)) + l
	}
	if m.SchemaID != 0 {
		n += 1 + sovHeartbeat(uint64(m.SchemaID))
	}
	return n
}

func (m *Table) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TableID != 0 {
		n += 1 + sovHeartbeat(uint64(m.TableID))
	}
	if m.SchemaID != 0 {
		n += 1 + sovHeartbeat(uint64(m.SchemaID))
	}
	if m.Splitable {
		n += 2
	}
	return n
}

func (m *SchemaIDChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TableID != 0 {
		n += 1 + sovHeartbeat(uint64(m.TableID))
	}
	if m.OldSchemaID != 0 {
		n += 1 + sovHeartbeat(uint64(m.OldSchemaID))
	}
	if m.NewSchemaID != 0 {
		n += 1 + sovHeartbeat(uint64(m.NewSchemaID))
	}
	return n
}

func (m *State) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsBlocked {
		n += 2
	}
	if m.BlockTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.BlockTs))
	}
	if m.BlockTables != nil {
		l = m.BlockTables.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.NeedDroppedTables != nil {
		l = m.NeedDroppedTables.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if len(m.NeedAddedTables) > 0 {
		for _, e := range m.NeedAddedTables {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if len(m.UpdatedSchemas) > 0 {
		for _, e := range m.UpdatedSchemas {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if m.IsSyncPoint {
		n += 2
	}
	if m.Stage != 0 {
		n += 1 + sovHeartbeat(uint64(m.Stage))
	}
	return n
}

func (m *TableSpanBlockStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovHeartbeat(uint64(m.Mode))
	}
	return n
}

func (m *TableSpanStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.ComponentStatus != 0 {
		n += 1 + sovHeartbeat(uint64(m.ComponentStatus))
	}
	if m.CheckpointTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.CheckpointTs))
	}
	if m.EventSizePerSecond != 0 {
		n += 5
	}
	if m.Mode != 0 {
		n += 1 + sovHeartbeat(uint64(m.Mode))
	}
	return n
}

func (m *BlockStatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if len(m.BlockStatuses) > 0 {
		for _, e := range m.BlockStatuses {
			l = e.Size()
			n += 1 + l + sovHeartbeat(uint64(l))
		}
	}
	if m.Mode != 0 {
		n += 1 + sovHeartbeat(uint64(m.Mode))
	}
	return n
}

func (m *RunningError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Time)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Node)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Code)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func (m *DispatcherID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.High != 0 {
		n += 1 + sovHeartbeat(uint64(m.High))
	}
	if m.Low != 0 {
		n += 1 + sovHeartbeat(uint64(m.Low))
	}
	return n
}

func (m *ChangefeedID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.High != 0 {
		n += 1 + sovHeartbeat(uint64(m.High))
	}
	if m.Low != 0 {
		n += 1 + sovHeartbeat(uint64(m.Low))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Keyspace)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func (m *LogCoordinatorResolvedTsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func (m *LogCoordinatorResolvedTsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.ResolvedTs != 0 {
		n += 1 + sovHeartbeat(uint64(m.ResolvedTs))
	}
	return n
}

func (m *ChecksumMeta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != 0 {
		n += 1 + sovHeartbeat(uint64(m.State))
	}
	if m.ChecksumStateSeq != 0 {
		n += 1 + sovHeartbeat(uint64(m.ChecksumStateSeq))
	}
	return n
}

func (m *DispatcherSetChecksum) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Count != 0 {
		n += 1 + sovHeartbeat(uint64(m.Count))
	}
	if m.XorHigh != 0 {
		n += 1 + sovHeartbeat(uint64(m.XorHigh))
	}
	if m.XorLow != 0 {
		n += 1 + sovHeartbeat(uint64(m.XorLow))
	}
	if m.SumHigh != 0 {
		n += 1 + sovHeartbeat(uint64(m.SumHigh))
	}
	if m.SumLow != 0 {
		n += 1 + sovHeartbeat(uint64(m.SumLow))
	}
	return n
}

func (m *DispatcherSetChecksumAckResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Epoch != 0 {
		n += 1 + sovHeartbeat(uint64(m.Epoch))
	}
	if m.Mode != 0 {
		n += 1 + sovHeartbeat(uint64(m.Mode))
	}
	if m.Seq != 0 {
		n += 1 + sovHeartbeat(uint64(m.Seq))
	}
	return n
}

func (m *DispatcherSetChecksumUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChangefeedID != nil {
		l = m.ChangefeedID.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Epoch != 0 {
		n += 1 + sovHeartbeat(uint64(m.Epoch))
	}
	if m.Mode != 0 {
		n += 1 + sovHeartbeat(uint64(m.Mode))
	}
	if m.Seq != 0 {
		n += 1 + sovHeartbeat(uint64(m.Seq))
	}
	if m.Checksum != nil {
		l = m.Checksum.Size()
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func sovHeartbeat(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozHeartbeat(x uint64) (n int) {
	return sovHeartbeat(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TableSpan) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TableSpan: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableSpan: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableID", wireType)
			}
			m.TableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TableID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
			if m.StartKey == nil {
				m.StartKey = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...)
			if m.EndKey == nil {
				m.EndKey = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceID", wireType)
			}
			m.KeyspaceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KeyspaceID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeartBeatRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HeartBeatRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartBeatRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Watermark", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Watermark == nil {
				m.Watermark = &Watermark{}
			}
			if err := m.Watermark.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedoWatermark", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RedoWatermark == nil {
				m.RedoWatermark = &Watermark{}
			}
			if err := m.RedoWatermark.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Statuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Statuses = append(m.Statuses, &TableSpanStatus{})
			if err := m.Statuses[len(m.Statuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompeleteStatus", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CompeleteStatus = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &RunningError{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Watermark) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Watermark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Watermark: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType)
			}
			m.CheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckpointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType)
			}
			m.ResolvedTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResolvedTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)
			}
			m.Seq = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seq |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastSyncedTs", wireType)
			}
			m.LastSyncedTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastSyncedTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DispatcherAction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DispatcherAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DispatcherAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			m.Action = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Action |= Action(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType)
			}
			m.CommitTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSyncPoint", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSyncPoint = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ACK) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ACK: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ACK: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType)
			}
			m.CommitTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSyncPoint", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSyncPoint = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InfluencedDispatchers) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InfluencedDispatchers: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InfluencedDispatchers: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfluenceType", wireType)
			}
			m.InfluenceType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InfluenceType |= InfluenceType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DispatcherIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DispatcherIDs = append(m.DispatcherIDs, &DispatcherID{})
			if err := m.DispatcherIDs[len(m.DispatcherIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaID", wireType)
			}
			m.SchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SchemaID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExcludeDispatcherId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExcludeDispatcherId == nil {
				m.ExcludeDispatcherId = &DispatcherID{}
			}
			if err := m.ExcludeDispatcherId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DispatcherStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DispatcherStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DispatcherStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfluencedDispatchers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InfluencedDispatchers == nil {
				m.InfluencedDispatchers = &InfluencedDispatchers{}
			}
			if err := m.InfluencedDispatchers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Action == nil {
				m.Action = &DispatcherAction{}
			}
			if err := m.Action.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ack", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Ack == nil {
				m.Ack = &ACK{}
			}
			if err := m.Ack.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeartBeatResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HeartBeatResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartBeatResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DispatcherStatuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DispatcherStatuses = append(m.DispatcherStatuses, &DispatcherStatus{})
			if err := m.DispatcherStatuses[len(m.DispatcherStatuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CheckpointTsMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CheckpointTsMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CheckpointTsMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType)
			}
			m.CheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckpointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RedoMetaMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RedoMetaMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RedoMetaMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType)
			}
			m.ResolvedTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResolvedTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType)
			}
			m.CheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckpointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RedoResolvedTsProgressMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RedoResolvedTsProgressMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RedoResolvedTsProgressMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType)
			}
			m.ResolvedTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResolvedTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RedoResolvedTsForwardMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RedoResolvedTsForwardMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RedoResolvedTsForwardMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType)
			}
			m.ResolvedTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResolvedTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DispatcherConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DispatcherConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DispatcherConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Span", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Span == nil {
				m.Span = &TableSpan{}
			}
			if err := m.Span.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
			}
			m.StartTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DispatcherID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DispatcherID == nil {
				m.DispatcherID = &DispatcherID{}
			}
			if err := m.DispatcherID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaID", wireType)
			}
			m.SchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SchemaID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipDMLAsStartTs", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SkipDMLAsStartTs = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ScheduleDispatcherRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ScheduleDispatcherRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScheduleDispatcherRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &DispatcherConfig{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScheduleAction", wireType)
			}
			m.ScheduleAction = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScheduleAction |= ScheduleAction(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperatorType", wireType)
			}
			m.OperatorType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OperatorType |= OperatorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MergeDispatcherRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MergeDispatcherRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MergeDispatcherRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DispatcherIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DispatcherIDs = append(m.DispatcherIDs, &DispatcherID{})
			if err := m.DispatcherIDs[len(m.DispatcherIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MergedDispatcherID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MergedDispatcherID == nil {
				m.MergedDispatcherID = &DispatcherID{}
			}
			if err := m.MergedDispatcherID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintainerHeartbeat) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MaintainerHeartbeat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintainerHeartbeat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Statuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Statuses = append(m.Statuses, &MaintainerStatus{})
			if err := m.Statuses[len(m.Statuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintainerStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MaintainerStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintainerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeedState", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeedState = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= ComponentState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType)
			}
			m.CheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckpointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Err = append(m.Err, &RunningError{})
			if err := m.Err[len(m.Err)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BootstrapDone", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.BootstrapDone = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastSyncedTs", wireType)
			}
			m.LastSyncedTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastSyncedTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CoordinatorBootstrapRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CoordinatorBootstrapRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CoordinatorBootstrapRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CoordinatorBootstrapResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CoordinatorBootstrapResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CoordinatorBootstrapResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Statuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Statuses = append(m.Statuses, &MaintainerStatus{})
			if err := m.Statuses[len(m.Statuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddMaintainerRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddMaintainerRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddMaintainerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &ChangefeedID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Config = append(m.Config[:0], dAtA[iNdEx:postIndex]...)
			if m.Config == nil {
				m.Config = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType)
			}
			m.CheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckpointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsNewChangefeed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsNewChangefeed = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceId", wireType)
			}
			m.KeyspaceId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KeyspaceId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveMaintainerRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RemoveMaintainerRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveMaintainerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &ChangefeedID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cascade", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Cascade = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Removed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Removed = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceId", wireType)
			}
			m.KeyspaceId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KeyspaceId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintainerBootstrapRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MaintainerBootstrapRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintainerBootstrapRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Config = append(m.Config[:0], dAtA[iNdEx:postIndex]...)
			if m.Config == nil {
				m.Config = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
			}
			m.StartTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableTriggerEventDispatcherId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TableTriggerEventDispatcherId == nil {
				m.TableTriggerEventDispatcherId = &DispatcherID{}
			}
			if err := m.TableTriggerEventDispatcherId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsNewChangefeed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsNewChangefeed = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableTriggerRedoDispatcherId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TableTriggerRedoDispatcherId == nil {
				m.TableTriggerRedoDispatcherId = &DispatcherID{}
			}
			if err := m.TableTriggerRedoDispatcherId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceId", wireType)
			}
			m.KeyspaceId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KeyspaceId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintainerBootstrapResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MaintainerBootstrapResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintainerBootstrapResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Spans = append(m.Spans, &BootstrapTableSpan{})
			if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &RunningError{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType)
			}
			m.CheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckpointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedoCheckpointTs", wireType)
			}
			m.RedoCheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RedoCheckpointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operators", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Operators = append(m.Operators, &ScheduleDispatcherRequest{})
			if err := m.Operators[len(m.Operators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintainerPostBootstrapRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MaintainerPostBootstrapRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintainerPostBootstrapRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableTriggerEventDispatcherId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TableTriggerEventDispatcherId == nil {
				m.TableTriggerEventDispatcherId = &DispatcherID{}
			}
			if err := m.TableTriggerEventDispatcherId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schemas = append(m.Schemas, &SchemaInfo{})
			if err := m.Schemas[len(m.Schemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedoSchemas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RedoSchemas = append(m.RedoSchemas, &SchemaInfo{})
			if err := m.RedoSchemas[len(m.RedoSchemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintainerPostBootstrapResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MaintainerPostBootstrapResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintainerPostBootstrapResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableTriggerEventDispatcherId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TableTriggerEventDispatcherId == nil {
				m.TableTriggerEventDispatcherId = &DispatcherID{}
			}
			if err := m.TableTriggerEventDispatcherId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &RunningError{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SchemaInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SchemaInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaID", wireType)
			}
			m.SchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SchemaID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SchemaName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tables = append(m.Tables, &TableInfo{})
			if err := m.Tables[len(m.Tables)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TableInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableID", wireType)
			}
			m.TableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TableID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BootstrapTableSpan) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BootstrapTableSpan: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BootstrapTableSpan: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &DispatcherID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaID", wireType)
			}
			m.SchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SchemaID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Span", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Span == nil {
				m.Span = &TableSpan{}
			}
			if err := m.Span.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ComponentStatus", wireType)
			}
			m.ComponentStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ComponentStatus |= ComponentState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType)
			}
			m.CheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckpointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BlockState == nil {
				m.BlockState = &State{}
			}
			if err := m.BlockState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintainerCloseRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MaintainerCloseRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintainerCloseRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Removed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Removed = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintainerCloseResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MaintainerCloseResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintainerCloseResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Success = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InfluencedTables) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InfluencedTables: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InfluencedTables: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfluenceType", wireType)
			}
			m.InfluenceType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InfluenceType |= InfluenceType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowHeartbeat
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.TableIDs = append(m.TableIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowHeartbeat
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthHeartbeat
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthHeartbeat
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.TableIDs) == 0 {
					m.TableIDs = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowHeartbeat
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.TableIDs = append(m.TableIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field TableIDs", wireType)
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaID", wireType)
			}
			m.SchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SchemaID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Table) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Table: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Table: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableID", wireType)
			}
			m.TableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TableID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaID", wireType)
			}
			m.SchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SchemaID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Splitable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Splitable = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SchemaIDChange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SchemaIDChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaIDChange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableID", wireType)
			}
			m.TableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TableID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldSchemaID", wireType)
			}
			m.OldSchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OldSchemaID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewSchemaID", wireType)
			}
			m.NewSchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NewSchemaID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *State) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: State: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: State: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsBlocked", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsBlocked = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockTs", wireType)
			}
			m.BlockTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockTables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BlockTables == nil {
				m.BlockTables = &InfluencedTables{}
			}
			if err := m.BlockTables.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NeedDroppedTables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NeedDroppedTables == nil {
				m.NeedDroppedTables = &InfluencedTables{}
			}
			if err := m.NeedDroppedTables.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NeedAddedTables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NeedAddedTables = append(m.NeedAddedTables, &Table{})
			if err := m.NeedAddedTables[len(m.NeedAddedTables)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedSchemas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpdatedSchemas = append(m.UpdatedSchemas, &SchemaIDChange{})
			if err := m.UpdatedSchemas[len(m.UpdatedSchemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSyncPoint", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSyncPoint = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stage", wireType)
			}
			m.Stage = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stage |= BlockStage(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableSpanBlockStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TableSpanBlockStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableSpanBlockStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &DispatcherID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &State{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableSpanStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TableSpanStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableSpanStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &DispatcherID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ComponentStatus", wireType)
			}
			m.ComponentStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ComponentStatus |= ComponentState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType)
			}
			m.CheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckpointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventSizePerSecond", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.EventSizePerSecond = float32(math.Float32frombits(v))
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockStatusRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockStatusRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockStatuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockStatuses = append(m.BlockStatuses, &TableSpanBlockStatus{})
			if err := m.BlockStatuses[len(m.BlockStatuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RunningError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RunningError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RunningError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Time = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Node = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Code = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DispatcherID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DispatcherID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DispatcherID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field High", wireType)
			}
			m.High = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.High |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Low", wireType)
			}
			m.Low = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Low |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangefeedID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ChangefeedID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChangefeedID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field High", wireType)
			}
			m.High = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.High |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Low", wireType)
			}
			m.Low = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Low |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Keyspace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogCoordinatorResolvedTsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LogCoordinatorResolvedTsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogCoordinatorResolvedTsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogCoordinatorResolvedTsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LogCoordinatorResolvedTsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogCoordinatorResolvedTsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType)
			}
			m.ResolvedTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResolvedTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChecksumMeta) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ChecksumMeta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChecksumMeta: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= ChecksumState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChecksumStateSeq", wireType)
			}
			m.ChecksumStateSeq = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChecksumStateSeq |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DispatcherSetChecksum) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DispatcherSetChecksum: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DispatcherSetChecksum: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field XorHigh", wireType)
			}
			m.XorHigh = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.XorHigh |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field XorLow", wireType)
			}
			m.XorLow = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.XorLow |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SumHigh", wireType)
			}
			m.SumHigh = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SumHigh |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SumLow", wireType)
			}
			m.SumLow = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SumLow |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DispatcherSetChecksumAckResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DispatcherSetChecksumAckResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DispatcherSetChecksumAckResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)
			}
			m.Seq = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seq |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DispatcherSetChecksumUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DispatcherSetChecksumUpdateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DispatcherSetChecksumUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangefeedID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedID == nil {
				m.ChangefeedID = &ChangefeedID{}
			}
			if err := m.ChangefeedID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)
			}
			m.Seq = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seq |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checksum", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Checksum == nil {
				m.Checksum = &DispatcherSetChecksum{}
			}
			if err := m.Checksum.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipHeartbeat(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthHeartbeat
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupHeartbeat
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthHeartbeat
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthHeartbeat        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowHeartbeat          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupHeartbeat = fmt.Errorf("proto: unexpected end of group")
)