// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: eventpb/event.proto

package eventpb

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	heartbeatpb "github.com/pingcap/ticdc/heartbeatpb"
	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 OpType int32

const (
	OpType_OpTypePut    OpType = 0
	OpType_OpTypeDelete OpType = 1
)

var OpType_name = map[int32]string{
	0: "OpTypePut",
	1: "OpTypeDelete",
}

var OpType_value = map[string]int32{
	"OpTypePut":    0,
	"OpTypeDelete": 1,
}

func (x OpType) String() string {
	return proto.EnumName(OpType_name, int32(x))
}

func (OpType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{0}
}

type ActionType int32

const (
	ActionType_ACTION_TYPE_UNSPECIFIED ActionType = 0
	ActionType_ACTION_TYPE_REGISTER    ActionType = 1
	ActionType_ACTION_TYPE_REMOVE      ActionType = 2
	// 3 and 4 are deprecated.
	ActionType_ACTION_TYPE_RESET ActionType = 5
)

var ActionType_name = map[int32]string{
	0: "ACTION_TYPE_UNSPECIFIED",
	1: "ACTION_TYPE_REGISTER",
	2: "ACTION_TYPE_REMOVE",
	5: "ACTION_TYPE_RESET",
}

var ActionType_value = map[string]int32{
	"ACTION_TYPE_UNSPECIFIED": 0,
	"ACTION_TYPE_REGISTER":    1,
	"ACTION_TYPE_REMOVE":      2,
	"ACTION_TYPE_RESET":       5,
}

func (x ActionType) String() string {
	return proto.EnumName(ActionType_name, int32(x))
}

func (ActionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{1}
}

type EventFilterRule struct {
	Matcher                  []string `protobuf:"bytes,1,rep,name=matcher,proto3" json:"matcher,omitempty"`
	IgnoreEvent              []string `protobuf:"bytes,2,rep,name=ignore_event,json=ignoreEvent,proto3" json:"ignore_event,omitempty"`
	IgnoreSql                []string `protobuf:"bytes,3,rep,name=ignore_sql,json=ignoreSql,proto3" json:"ignore_sql,omitempty"`
	IgnoreInsertValueExpr    string   `protobuf:"bytes,4,opt,name=ignore_insert_value_expr,json=ignoreInsertValueExpr,proto3" json:"ignore_insert_value_expr,omitempty"`
	IgnoreUpdateNewValueExpr string   `protobuf:"bytes,5,opt,name=ignore_update_new_value_expr,json=ignoreUpdateNewValueExpr,proto3" json:"ignore_update_new_value_expr,omitempty"`
	IgnoreUpdateOldValueExpr string   `protobuf:"bytes,6,opt,name=ignore_update_old_value_expr,json=ignoreUpdateOldValueExpr,proto3" json:"ignore_update_old_value_expr,omitempty"`
	IgnoreDeleteValueExpr    string   `protobuf:"bytes,7,opt,name=ignore_delete_value_expr,json=ignoreDeleteValueExpr,proto3" json:"ignore_delete_value_expr,omitempty"`
}

func (m *EventFilterRule) Reset()         { *m = EventFilterRule{} }
func (m *EventFilterRule) String() string { return proto.CompactTextString(m) }
func (*EventFilterRule) ProtoMessage()    {}
func (*EventFilterRule) Descriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{0}
}
func (m *EventFilterRule) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventFilterRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventFilterRule.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 *EventFilterRule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventFilterRule.Merge(m, src)
}
func (m *EventFilterRule) XXX_Size() int {
	return m.Size()
}
func (m *EventFilterRule) XXX_DiscardUnknown() {
	xxx_messageInfo_EventFilterRule.DiscardUnknown(m)
}

var xxx_messageInfo_EventFilterRule proto.InternalMessageInfo

func (m *EventFilterRule) GetMatcher() []string {
	if m != nil {
		return m.Matcher
	}
	return nil
}

func (m *EventFilterRule) GetIgnoreEvent() []string {
	if m != nil {
		return m.IgnoreEvent
	}
	return nil
}

func (m *EventFilterRule) GetIgnoreSql() []string {
	if m != nil {
		return m.IgnoreSql
	}
	return nil
}

func (m *EventFilterRule) GetIgnoreInsertValueExpr() string {
	if m != nil {
		return m.IgnoreInsertValueExpr
	}
	return ""
}

func (m *EventFilterRule) GetIgnoreUpdateNewValueExpr() string {
	if m != nil {
		return m.IgnoreUpdateNewValueExpr
	}
	return ""
}

func (m *EventFilterRule) GetIgnoreUpdateOldValueExpr() string {
	if m != nil {
		return m.IgnoreUpdateOldValueExpr
	}
	return ""
}

func (m *EventFilterRule) GetIgnoreDeleteValueExpr() string {
	if m != nil {
		return m.IgnoreDeleteValueExpr
	}
	return ""
}

type InnerFilterConfig struct {
	Rules            []string           `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"`
	IgnoreTxnStartTs []uint64           `protobuf:"varint,2,rep,packed,name=ignore_txn_start_ts,json=ignoreTxnStartTs,proto3" json:"ignore_txn_start_ts,omitempty"`
	EventFilters     []*EventFilterRule `protobuf:"bytes,3,rep,name=EventFilters,proto3" json:"EventFilters,omitempty"`
}

func (m *InnerFilterConfig) Reset()         { *m = InnerFilterConfig{} }
func (m *InnerFilterConfig) String() string { return proto.CompactTextString(m) }
func (*InnerFilterConfig) ProtoMessage()    {}
func (*InnerFilterConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{1}
}
func (m *InnerFilterConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InnerFilterConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InnerFilterConfig.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 *InnerFilterConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InnerFilterConfig.Merge(m, src)
}
func (m *InnerFilterConfig) XXX_Size() int {
	return m.Size()
}
func (m *InnerFilterConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_InnerFilterConfig.DiscardUnknown(m)
}

var xxx_messageInfo_InnerFilterConfig proto.InternalMessageInfo

func (m *InnerFilterConfig) GetRules() []string {
	if m != nil {
		return m.Rules
	}
	return nil
}

func (m *InnerFilterConfig) GetIgnoreTxnStartTs() []uint64 {
	if m != nil {
		return m.IgnoreTxnStartTs
	}
	return nil
}

func (m *InnerFilterConfig) GetEventFilters() []*EventFilterRule {
	if m != nil {
		return m.EventFilters
	}
	return nil
}

type FilterConfig struct {
	CaseSensitive  bool               `protobuf:"varint,1,opt,name=caseSensitive,proto3" json:"caseSensitive,omitempty"`
	ForceReplicate bool               `protobuf:"varint,2,opt,name=forceReplicate,proto3" json:"forceReplicate,omitempty"`
	FilterConfig   *InnerFilterConfig `protobuf:"bytes,3,opt,name=filterConfig,proto3" json:"filterConfig,omitempty"`
}

func (m *FilterConfig) Reset()         { *m = FilterConfig{} }
func (m *FilterConfig) String() string { return proto.CompactTextString(m) }
func (*FilterConfig) ProtoMessage()    {}
func (*FilterConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{2}
}
func (m *FilterConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FilterConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FilterConfig.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 *FilterConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FilterConfig.Merge(m, src)
}
func (m *FilterConfig) XXX_Size() int {
	return m.Size()
}
func (m *FilterConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_FilterConfig.DiscardUnknown(m)
}

var xxx_messageInfo_FilterConfig proto.InternalMessageInfo

func (m *FilterConfig) GetCaseSensitive() bool {
	if m != nil {
		return m.CaseSensitive
	}
	return false
}

func (m *FilterConfig) GetForceReplicate() bool {
	if m != nil {
		return m.ForceReplicate
	}
	return false
}

func (m *FilterConfig) GetFilterConfig() *InnerFilterConfig {
	if m != nil {
		return m.FilterConfig
	}
	return nil
}

type ResolvedTs struct {
}

func (m *ResolvedTs) Reset()         { *m = ResolvedTs{} }
func (m *ResolvedTs) String() string { return proto.CompactTextString(m) }
func (*ResolvedTs) ProtoMessage()    {}
func (*ResolvedTs) Descriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{3}
}
func (m *ResolvedTs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResolvedTs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ResolvedTs.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 *ResolvedTs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResolvedTs.Merge(m, src)
}
func (m *ResolvedTs) XXX_Size() int {
	return m.Size()
}
func (m *ResolvedTs) XXX_DiscardUnknown() {
	xxx_messageInfo_ResolvedTs.DiscardUnknown(m)
}

var xxx_messageInfo_ResolvedTs proto.InternalMessageInfo

type Event struct {
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// nil for delete type
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// nil for insert type
	OldValue []byte `protobuf:"bytes,3,opt,name=OldValue,proto3" json:"OldValue,omitempty"`
	OpType   OpType `protobuf:"varint,4,opt,name=op_type,json=opType,proto3,enum=eventpb.OpType" json:"op_type,omitempty"`
}

func (m *Event) Reset()         { *m = Event{} }
func (m *Event) String() string { return proto.CompactTextString(m) }
func (*Event) ProtoMessage()    {}
func (*Event) Descriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{4}
}
func (m *Event) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Event.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 *Event) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Event.Merge(m, src)
}
func (m *Event) XXX_Size() int {
	return m.Size()
}
func (m *Event) XXX_DiscardUnknown() {
	xxx_messageInfo_Event.DiscardUnknown(m)
}

var xxx_messageInfo_Event proto.InternalMessageInfo

func (m *Event) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *Event) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Event) GetOldValue() []byte {
	if m != nil {
		return m.OldValue
	}
	return nil
}

func (m *Event) GetOpType() OpType {
	if m != nil {
		return m.OpType
	}
	return OpType_OpTypePut
}

type TxnEvent struct {
	Events   []*Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	CommitTs uint64   `protobuf:"varint,2,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"`
	StartTs  uint64   `protobuf:"varint,3,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
}

func (m *TxnEvent) Reset()         { *m = TxnEvent{} }
func (m *TxnEvent) String() string { return proto.CompactTextString(m) }
func (*TxnEvent) ProtoMessage()    {}
func (*TxnEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{5}
}
func (m *TxnEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TxnEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TxnEvent.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 *TxnEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TxnEvent.Merge(m, src)
}
func (m *TxnEvent) XXX_Size() int {
	return m.Size()
}
func (m *TxnEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_TxnEvent.DiscardUnknown(m)
}

var xxx_messageInfo_TxnEvent proto.InternalMessageInfo

func (m *TxnEvent) GetEvents() []*Event {
	if m != nil {
		return m.Events
	}
	return nil
}

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

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

type TableInfo struct {
}

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_d7fb2554dfcf7f7d, []int{6}
}
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

type EventFeed struct {
	TxnEvents    []*TxnEvent               `protobuf:"bytes,1,rep,name=txn_events,json=txnEvents,proto3" json:"txn_events,omitempty"`
	ResolvedTs   uint64                    `protobuf:"varint,2,opt,name=resolved_ts,json=resolvedTs,proto3" json:"resolved_ts,omitempty"`
	DispatcherId *heartbeatpb.DispatcherID `protobuf:"bytes,3,opt,name=dispatcher_id,json=dispatcherId,proto3" json:"dispatcher_id,omitempty"`
	Ratio        float32                   `protobuf:"fixed32,4,opt,name=ratio,proto3" json:"ratio,omitempty"`
	TableInfo    *TableInfo                `protobuf:"bytes,5,opt,name=table_info,json=tableInfo,proto3" json:"table_info,omitempty"`
}

func (m *EventFeed) Reset()         { *m = EventFeed{} }
func (m *EventFeed) String() string { return proto.CompactTextString(m) }
func (*EventFeed) ProtoMessage()    {}
func (*EventFeed) Descriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{7}
}
func (m *EventFeed) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventFeed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventFeed.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 *EventFeed) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventFeed.Merge(m, src)
}
func (m *EventFeed) XXX_Size() int {
	return m.Size()
}
func (m *EventFeed) XXX_DiscardUnknown() {
	xxx_messageInfo_EventFeed.DiscardUnknown(m)
}

var xxx_messageInfo_EventFeed proto.InternalMessageInfo

func (m *EventFeed) GetTxnEvents() []*TxnEvent {
	if m != nil {
		return m.TxnEvents
	}
	return nil
}

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

func (m *EventFeed) GetDispatcherId() *heartbeatpb.DispatcherID {
	if m != nil {
		return m.DispatcherId
	}
	return nil
}

func (m *EventFeed) GetRatio() float32 {
	if m != nil {
		return m.Ratio
	}
	return 0
}

func (m *EventFeed) GetTableInfo() *TableInfo {
	if m != nil {
		return m.TableInfo
	}
	return nil
}

type IntegrityConfig struct {
	IntegrityCheckLevel   string `protobuf:"bytes,1,opt,name=IntegrityCheckLevel,proto3" json:"IntegrityCheckLevel,omitempty"`
	CorruptionHandleLevel string `protobuf:"bytes,2,opt,name=CorruptionHandleLevel,proto3" json:"CorruptionHandleLevel,omitempty"`
}

func (m *IntegrityConfig) Reset()         { *m = IntegrityConfig{} }
func (m *IntegrityConfig) String() string { return proto.CompactTextString(m) }
func (*IntegrityConfig) ProtoMessage()    {}
func (*IntegrityConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{8}
}
func (m *IntegrityConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IntegrityConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IntegrityConfig.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 *IntegrityConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IntegrityConfig.Merge(m, src)
}
func (m *IntegrityConfig) XXX_Size() int {
	return m.Size()
}
func (m *IntegrityConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_IntegrityConfig.DiscardUnknown(m)
}

var xxx_messageInfo_IntegrityConfig proto.InternalMessageInfo

func (m *IntegrityConfig) GetIntegrityCheckLevel() string {
	if m != nil {
		return m.IntegrityCheckLevel
	}
	return ""
}

func (m *IntegrityConfig) GetCorruptionHandleLevel() string {
	if m != nil {
		return m.CorruptionHandleLevel
	}
	return ""
}

// DispatcherRequest is used to send a dispatcher request to the event service.
// A request can be a register, remove, reset dispatcher request.
type DispatcherRequest struct {
	// cluster_id is the id of the TiDB cluster that the dispatcher belongs to.
	ClusterId            uint64                    `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	ChangefeedId         *heartbeatpb.ChangefeedID `protobuf:"bytes,2,opt,name=changefeed_id,json=changefeedId,proto3" json:"changefeed_id,omitempty"`
	DispatcherId         *heartbeatpb.DispatcherID `protobuf:"bytes,3,opt,name=dispatcher_id,json=dispatcherId,proto3" json:"dispatcher_id,omitempty"`
	TableSpan            *heartbeatpb.TableSpan    `protobuf:"bytes,4,opt,name=table_span,json=tableSpan,proto3" json:"table_span,omitempty"`
	StartTs              uint64                    `protobuf:"varint,5,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
	ServerId             string                    `protobuf:"bytes,6,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
	ActionType           ActionType                `protobuf:"varint,7,opt,name=action_type,json=actionType,proto3,enum=eventpb.ActionType" json:"action_type,omitempty"`
	FilterConfig         *FilterConfig             `protobuf:"bytes,8,opt,name=filter_config,json=filterConfig,proto3" json:"filter_config,omitempty"`
	EnableSyncPoint      bool                      `protobuf:"varint,9,opt,name=enable_sync_point,json=enableSyncPoint,proto3" json:"enable_sync_point,omitempty"`
	SyncPointTs          uint64                    `protobuf:"varint,10,opt,name=sync_point_ts,json=syncPointTs,proto3" json:"sync_point_ts,omitempty"`
	SyncPointInterval    uint64                    `protobuf:"varint,11,opt,name=sync_point_interval,json=syncPointInterval,proto3" json:"sync_point_interval,omitempty"`
	OnlyReuse            bool                      `protobuf:"varint,12,opt,name=only_reuse,json=onlyReuse,proto3" json:"only_reuse,omitempty"`
	BdrMode              bool                      `protobuf:"varint,13,opt,name=bdr_mode,json=bdrMode,proto3" json:"bdr_mode,omitempty"`
	Integrity            *IntegrityConfig          `protobuf:"bytes,14,opt,name=integrity,proto3" json:"integrity,omitempty"`
	Timezone             string                    `protobuf:"bytes,15,opt,name=timezone,proto3" json:"timezone,omitempty"`
	Epoch                uint64                    `protobuf:"varint,16,opt,name=epoch,proto3" json:"epoch,omitempty"`
	OutputRawChangeEvent bool                      `protobuf:"varint,17,opt,name=output_raw_change_event,json=outputRawChangeEvent,proto3" json:"output_raw_change_event,omitempty"`
	Mode                 int64                     `protobuf:"varint,18,opt,name=mode,proto3" json:"mode,omitempty"`
	TxnAtomicity         string                    `protobuf:"bytes,19,opt,name=txn_atomicity,json=txnAtomicity,proto3" json:"txn_atomicity,omitempty"`
}

func (m *DispatcherRequest) Reset()         { *m = DispatcherRequest{} }
func (m *DispatcherRequest) String() string { return proto.CompactTextString(m) }
func (*DispatcherRequest) ProtoMessage()    {}
func (*DispatcherRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_d7fb2554dfcf7f7d, []int{9}
}
func (m *DispatcherRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DispatcherRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DispatcherRequest.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 *DispatcherRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DispatcherRequest.Merge(m, src)
}
func (m *DispatcherRequest) XXX_Size() int {
	return m.Size()
}
func (m *DispatcherRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DispatcherRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DispatcherRequest proto.InternalMessageInfo

func (m *DispatcherRequest) GetClusterId() uint64 {
	if m != nil {
		return m.ClusterId
	}
	return 0
}

func (m *DispatcherRequest) GetChangefeedId() *heartbeatpb.ChangefeedID {
	if m != nil {
		return m.ChangefeedId
	}
	return nil
}

func (m *DispatcherRequest) GetDispatcherId() *heartbeatpb.DispatcherID {
	if m != nil {
		return m.DispatcherId
	}
	return nil
}

func (m *DispatcherRequest) GetTableSpan() *heartbeatpb.TableSpan {
	if m != nil {
		return m.TableSpan
	}
	return nil
}

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

func (m *DispatcherRequest) GetServerId() string {
	if m != nil {
		return m.ServerId
	}
	return ""
}

func (m *DispatcherRequest) GetActionType() ActionType {
	if m != nil {
		return m.ActionType
	}
	return ActionType_ACTION_TYPE_UNSPECIFIED
}

func (m *DispatcherRequest) GetFilterConfig() *FilterConfig {
	if m != nil {
		return m.FilterConfig
	}
	return nil
}

func (m *DispatcherRequest) GetEnableSyncPoint() bool {
	if m != nil {
		return m.EnableSyncPoint
	}
	return false
}

func (m *DispatcherRequest) GetSyncPointTs() uint64 {
	if m != nil {
		return m.SyncPointTs
	}
	return 0
}

func (m *DispatcherRequest) GetSyncPointInterval() uint64 {
	if m != nil {
		return m.SyncPointInterval
	}
	return 0
}

func (m *DispatcherRequest) GetOnlyReuse() bool {
	if m != nil {
		return m.OnlyReuse
	}
	return false
}

func (m *DispatcherRequest) GetBdrMode() bool {
	if m != nil {
		return m.BdrMode
	}
	return false
}

func (m *DispatcherRequest) GetIntegrity() *IntegrityConfig {
	if m != nil {
		return m.Integrity
	}
	return nil
}

func (m *DispatcherRequest) GetTimezone() string {
	if m != nil {
		return m.Timezone
	}
	return ""
}

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

func (m *DispatcherRequest) GetOutputRawChangeEvent() bool {
	if m != nil {
		return m.OutputRawChangeEvent
	}
	return false
}

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

func (m *DispatcherRequest) GetTxnAtomicity() string {
	if m != nil {
		return m.TxnAtomicity
	}
	return ""
}

func init() {
	proto.RegisterEnum("eventpb.OpType", OpType_name, OpType_value)
	proto.RegisterEnum("eventpb.ActionType", ActionType_name, ActionType_value)
	proto.RegisterType((*EventFilterRule)(nil), "eventpb.EventFilterRule")
	proto.RegisterType((*InnerFilterConfig)(nil), "eventpb.InnerFilterConfig")
	proto.RegisterType((*FilterConfig)(nil), "eventpb.FilterConfig")
	proto.RegisterType((*ResolvedTs)(nil), "eventpb.ResolvedTs")
	proto.RegisterType((*Event)(nil), "eventpb.Event")
	proto.RegisterType((*TxnEvent)(nil), "eventpb.TxnEvent")
	proto.RegisterType((*TableInfo)(nil), "eventpb.TableInfo")
	proto.RegisterType((*EventFeed)(nil), "eventpb.EventFeed")
	proto.RegisterType((*IntegrityConfig)(nil), "eventpb.IntegrityConfig")
	proto.RegisterType((*DispatcherRequest)(nil), "eventpb.DispatcherRequest")
}

func init() { proto.RegisterFile("eventpb/event.proto", fileDescriptor_d7fb2554dfcf7f7d) }

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

func (m *EventFilterRule) 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 *EventFilterRule) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventFilterRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IgnoreDeleteValueExpr) > 0 {
		i -= len(m.IgnoreDeleteValueExpr)
		copy(dAtA[i:], m.IgnoreDeleteValueExpr)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.IgnoreDeleteValueExpr)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.IgnoreUpdateOldValueExpr) > 0 {
		i -= len(m.IgnoreUpdateOldValueExpr)
		copy(dAtA[i:], m.IgnoreUpdateOldValueExpr)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.IgnoreUpdateOldValueExpr)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.IgnoreUpdateNewValueExpr) > 0 {
		i -= len(m.IgnoreUpdateNewValueExpr)
		copy(dAtA[i:], m.IgnoreUpdateNewValueExpr)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.IgnoreUpdateNewValueExpr)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.IgnoreInsertValueExpr) > 0 {
		i -= len(m.IgnoreInsertValueExpr)
		copy(dAtA[i:], m.IgnoreInsertValueExpr)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.IgnoreInsertValueExpr)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.IgnoreSql) > 0 {
		for iNdEx := len(m.IgnoreSql) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.IgnoreSql[iNdEx])
			copy(dAtA[i:], m.IgnoreSql[iNdEx])
			i = encodeVarintEvent(dAtA, i, uint64(len(m.IgnoreSql[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.IgnoreEvent) > 0 {
		for iNdEx := len(m.IgnoreEvent) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.IgnoreEvent[iNdEx])
			copy(dAtA[i:], m.IgnoreEvent[iNdEx])
			i = encodeVarintEvent(dAtA, i, uint64(len(m.IgnoreEvent[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Matcher) > 0 {
		for iNdEx := len(m.Matcher) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Matcher[iNdEx])
			copy(dAtA[i:], m.Matcher[iNdEx])
			i = encodeVarintEvent(dAtA, i, uint64(len(m.Matcher[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *InnerFilterConfig) 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 *InnerFilterConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InnerFilterConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EventFilters) > 0 {
		for iNdEx := len(m.EventFilters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EventFilters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.IgnoreTxnStartTs) > 0 {
		dAtA2 := make([]byte, len(m.IgnoreTxnStartTs)*10)
		var j1 int
		for _, num := range m.IgnoreTxnStartTs {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintEvent(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Rules) > 0 {
		for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Rules[iNdEx])
			copy(dAtA[i:], m.Rules[iNdEx])
			i = encodeVarintEvent(dAtA, i, uint64(len(m.Rules[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *FilterConfig) 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 *FilterConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FilterConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FilterConfig != nil {
		{
			size, err := m.FilterConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ForceReplicate {
		i--
		if m.ForceReplicate {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.CaseSensitive {
		i--
		if m.CaseSensitive {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResolvedTs) 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 *ResolvedTs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResolvedTs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *Event) 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 *Event) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OpType != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.OpType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.OldValue) > 0 {
		i -= len(m.OldValue)
		copy(dAtA[i:], m.OldValue)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.OldValue)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TxnEvent) 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 *TxnEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TxnEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StartTs != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.StartTs))
		i--
		dAtA[i] = 0x18
	}
	if m.CommitTs != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.CommitTs))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Events) > 0 {
		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	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
	return len(dAtA) - i, nil
}

func (m *EventFeed) 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 *EventFeed) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventFeed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TableInfo != nil {
		{
			size, err := m.TableInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Ratio != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Ratio))))
		i--
		dAtA[i] = 0x25
	}
	if m.DispatcherId != nil {
		{
			size, err := m.DispatcherId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ResolvedTs != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.ResolvedTs))
		i--
		dAtA[i] = 0x10
	}
	if len(m.TxnEvents) > 0 {
		for iNdEx := len(m.TxnEvents) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TxnEvents[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *IntegrityConfig) 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 *IntegrityConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IntegrityConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CorruptionHandleLevel) > 0 {
		i -= len(m.CorruptionHandleLevel)
		copy(dAtA[i:], m.CorruptionHandleLevel)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.CorruptionHandleLevel)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.IntegrityCheckLevel) > 0 {
		i -= len(m.IntegrityCheckLevel)
		copy(dAtA[i:], m.IntegrityCheckLevel)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.IntegrityCheckLevel)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DispatcherRequest) 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 *DispatcherRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DispatcherRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TxnAtomicity) > 0 {
		i -= len(m.TxnAtomicity)
		copy(dAtA[i:], m.TxnAtomicity)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.TxnAtomicity)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if m.Mode != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if m.OutputRawChangeEvent {
		i--
		if m.OutputRawChangeEvent {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.Epoch != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.Epoch))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if len(m.Timezone) > 0 {
		i -= len(m.Timezone)
		copy(dAtA[i:], m.Timezone)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.Timezone)))
		i--
		dAtA[i] = 0x7a
	}
	if m.Integrity != nil {
		{
			size, err := m.Integrity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if m.BdrMode {
		i--
		if m.BdrMode {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.OnlyReuse {
		i--
		if m.OnlyReuse {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if m.SyncPointInterval != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.SyncPointInterval))
		i--
		dAtA[i] = 0x58
	}
	if m.SyncPointTs != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.SyncPointTs))
		i--
		dAtA[i] = 0x50
	}
	if m.EnableSyncPoint {
		i--
		if m.EnableSyncPoint {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x48
	}
	if m.FilterConfig != nil {
		{
			size, err := m.FilterConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.ActionType != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.ActionType))
		i--
		dAtA[i] = 0x38
	}
	if len(m.ServerId) > 0 {
		i -= len(m.ServerId)
		copy(dAtA[i:], m.ServerId)
		i = encodeVarintEvent(dAtA, i, uint64(len(m.ServerId)))
		i--
		dAtA[i] = 0x32
	}
	if m.StartTs != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.StartTs))
		i--
		dAtA[i] = 0x28
	}
	if m.TableSpan != nil {
		{
			size, err := m.TableSpan.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.DispatcherId != nil {
		{
			size, err := m.DispatcherId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ChangefeedId != nil {
		{
			size, err := m.ChangefeedId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ClusterId != 0 {
		i = encodeVarintEvent(dAtA, i, uint64(m.ClusterId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintEvent(dAtA []byte, offset int, v uint64) int {
	offset -= sovEvent(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *EventFilterRule) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Matcher) > 0 {
		for _, s := range m.Matcher {
			l = len(s)
			n += 1 + l + sovEvent(uint64(l))
		}
	}
	if len(m.IgnoreEvent) > 0 {
		for _, s := range m.IgnoreEvent {
			l = len(s)
			n += 1 + l + sovEvent(uint64(l))
		}
	}
	if len(m.IgnoreSql) > 0 {
		for _, s := range m.IgnoreSql {
			l = len(s)
			n += 1 + l + sovEvent(uint64(l))
		}
	}
	l = len(m.IgnoreInsertValueExpr)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.IgnoreUpdateNewValueExpr)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.IgnoreUpdateOldValueExpr)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.IgnoreDeleteValueExpr)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	return n
}

func (m *InnerFilterConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Rules) > 0 {
		for _, s := range m.Rules {
			l = len(s)
			n += 1 + l + sovEvent(uint64(l))
		}
	}
	if len(m.IgnoreTxnStartTs) > 0 {
		l = 0
		for _, e := range m.IgnoreTxnStartTs {
			l += sovEvent(uint64(e))
		}
		n += 1 + sovEvent(uint64(l)) + l
	}
	if len(m.EventFilters) > 0 {
		for _, e := range m.EventFilters {
			l = e.Size()
			n += 1 + l + sovEvent(uint64(l))
		}
	}
	return n
}

func (m *FilterConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CaseSensitive {
		n += 2
	}
	if m.ForceReplicate {
		n += 2
	}
	if m.FilterConfig != nil {
		l = m.FilterConfig.Size()
		n += 1 + l + sovEvent(uint64(l))
	}
	return n
}

func (m *ResolvedTs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *Event) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.OldValue)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.OpType != 0 {
		n += 1 + sovEvent(uint64(m.OpType))
	}
	return n
}

func (m *TxnEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Events) > 0 {
		for _, e := range m.Events {
			l = e.Size()
			n += 1 + l + sovEvent(uint64(l))
		}
	}
	if m.CommitTs != 0 {
		n += 1 + sovEvent(uint64(m.CommitTs))
	}
	if m.StartTs != 0 {
		n += 1 + sovEvent(uint64(m.StartTs))
	}
	return n
}

func (m *TableInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventFeed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.TxnEvents) > 0 {
		for _, e := range m.TxnEvents {
			l = e.Size()
			n += 1 + l + sovEvent(uint64(l))
		}
	}
	if m.ResolvedTs != 0 {
		n += 1 + sovEvent(uint64(m.ResolvedTs))
	}
	if m.DispatcherId != nil {
		l = m.DispatcherId.Size()
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.Ratio != 0 {
		n += 5
	}
	if m.TableInfo != nil {
		l = m.TableInfo.Size()
		n += 1 + l + sovEvent(uint64(l))
	}
	return n
}

func (m *IntegrityConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.IntegrityCheckLevel)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.CorruptionHandleLevel)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	return n
}

func (m *DispatcherRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ClusterId != 0 {
		n += 1 + sovEvent(uint64(m.ClusterId))
	}
	if m.ChangefeedId != nil {
		l = m.ChangefeedId.Size()
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.DispatcherId != nil {
		l = m.DispatcherId.Size()
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.TableSpan != nil {
		l = m.TableSpan.Size()
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.StartTs != 0 {
		n += 1 + sovEvent(uint64(m.StartTs))
	}
	l = len(m.ServerId)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.ActionType != 0 {
		n += 1 + sovEvent(uint64(m.ActionType))
	}
	if m.FilterConfig != nil {
		l = m.FilterConfig.Size()
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.EnableSyncPoint {
		n += 2
	}
	if m.SyncPointTs != 0 {
		n += 1 + sovEvent(uint64(m.SyncPointTs))
	}
	if m.SyncPointInterval != 0 {
		n += 1 + sovEvent(uint64(m.SyncPointInterval))
	}
	if m.OnlyReuse {
		n += 2
	}
	if m.BdrMode {
		n += 2
	}
	if m.Integrity != nil {
		l = m.Integrity.Size()
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.Timezone)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.Epoch != 0 {
		n += 2 + sovEvent(uint64(m.Epoch))
	}
	if m.OutputRawChangeEvent {
		n += 3
	}
	if m.Mode != 0 {
		n += 2 + sovEvent(uint64(m.Mode))
	}
	l = len(m.TxnAtomicity)
	if l > 0 {
		n += 2 + l + sovEvent(uint64(l))
	}
	return n
}

func sovEvent(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozEvent(x uint64) (n int) {
	return sovEvent(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *EventFilterRule) 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 ErrIntOverflowEvent
			}
			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: EventFilterRule: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventFilterRule: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Matcher", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Matcher = append(m.Matcher, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreEvent", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IgnoreEvent = append(m.IgnoreEvent, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreSql", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IgnoreSql = append(m.IgnoreSql, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreInsertValueExpr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IgnoreInsertValueExpr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreUpdateNewValueExpr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IgnoreUpdateNewValueExpr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreUpdateOldValueExpr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IgnoreUpdateOldValueExpr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreDeleteValueExpr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IgnoreDeleteValueExpr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InnerFilterConfig) 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 ErrIntOverflowEvent
			}
			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: InnerFilterConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InnerFilterConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Rules = append(m.Rules, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEvent
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.IgnoreTxnStartTs = append(m.IgnoreTxnStartTs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEvent
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthEvent
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthEvent
				}
				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.IgnoreTxnStartTs) == 0 {
					m.IgnoreTxnStartTs = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEvent
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.IgnoreTxnStartTs = append(m.IgnoreTxnStartTs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreTxnStartTs", wireType)
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventFilters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventFilters = append(m.EventFilters, &EventFilterRule{})
			if err := m.EventFilters[len(m.EventFilters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FilterConfig) 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 ErrIntOverflowEvent
			}
			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: FilterConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FilterConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CaseSensitive", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CaseSensitive = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForceReplicate", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ForceReplicate = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilterConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FilterConfig == nil {
				m.FilterConfig = &InnerFilterConfig{}
			}
			if err := m.FilterConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResolvedTs) 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 ErrIntOverflowEvent
			}
			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: ResolvedTs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResolvedTs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Event) 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 ErrIntOverflowEvent
			}
			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: Event: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
			if m.Key == nil {
				m.Key = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldValue", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OldValue = append(m.OldValue[:0], dAtA[iNdEx:postIndex]...)
			if m.OldValue == nil {
				m.OldValue = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OpType", wireType)
			}
			m.OpType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OpType |= OpType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TxnEvent) 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 ErrIntOverflowEvent
			}
			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: TxnEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxnEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Events = append(m.Events, &Event{})
			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		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 ErrIntOverflowEvent
				}
				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 StartTs", wireType)
			}
			m.StartTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			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 ErrIntOverflowEvent
			}
			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 {
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventFeed) 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 ErrIntOverflowEvent
			}
			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: EventFeed: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventFeed: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnEvents", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnEvents = append(m.TxnEvents, &TxnEvent{})
			if err := m.TxnEvents[len(m.TxnEvents)-1].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 ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResolvedTs |= 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 ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DispatcherId == nil {
				m.DispatcherId = &heartbeatpb.DispatcherID{}
			}
			if err := m.DispatcherId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ratio", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Ratio = float32(math.Float32frombits(v))
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TableInfo == nil {
				m.TableInfo = &TableInfo{}
			}
			if err := m.TableInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IntegrityConfig) 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 ErrIntOverflowEvent
			}
			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: IntegrityConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IntegrityConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntegrityCheckLevel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IntegrityCheckLevel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CorruptionHandleLevel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CorruptionHandleLevel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DispatcherRequest) 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 ErrIntOverflowEvent
			}
			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: DispatcherRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DispatcherRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			m.ClusterId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClusterId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangefeedId == nil {
				m.ChangefeedId = &heartbeatpb.ChangefeedID{}
			}
			if err := m.ChangefeedId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		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 ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DispatcherId == nil {
				m.DispatcherId = &heartbeatpb.DispatcherID{}
			}
			if err := m.DispatcherId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableSpan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TableSpan == nil {
				m.TableSpan = &heartbeatpb.TableSpan{}
			}
			if err := m.TableSpan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActionType", wireType)
			}
			m.ActionType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActionType |= ActionType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilterConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FilterConfig == nil {
				m.FilterConfig = &FilterConfig{}
			}
			if err := m.FilterConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableSyncPoint", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableSyncPoint = bool(v != 0)
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncPointTs", wireType)
			}
			m.SyncPointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SyncPointTs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncPointInterval", wireType)
			}
			m.SyncPointInterval = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SyncPointInterval |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnlyReuse", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OnlyReuse = bool(v != 0)
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BdrMode", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.BdrMode = bool(v != 0)
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Integrity", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Integrity == nil {
				m.Integrity = &IntegrityConfig{}
			}
			if err := m.Integrity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timezone", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timezone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			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 ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputRawChangeEvent", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OutputRawChangeEvent = bool(v != 0)
		case 18:
			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 ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnAtomicity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnAtomicity = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipEvent(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, ErrIntOverflowEvent
			}
			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, ErrIntOverflowEvent
				}
				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, ErrIntOverflowEvent
				}
				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, ErrInvalidLengthEvent
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupEvent
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthEvent
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthEvent        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvent          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvent = fmt.Errorf("proto: unexpected end of group")
)