// Code generated by protoc-gen-go. DO NOT EDIT.
// source: WAL.proto

package pb

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

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

type ScopeType int32

const (
	ScopeType_REPLICATION_SCOPE_LOCAL  ScopeType = 0
	ScopeType_REPLICATION_SCOPE_GLOBAL ScopeType = 1
)

var ScopeType_name = map[int32]string{
	0: "REPLICATION_SCOPE_LOCAL",
	1: "REPLICATION_SCOPE_GLOBAL",
}
var ScopeType_value = map[string]int32{
	"REPLICATION_SCOPE_LOCAL":  0,
	"REPLICATION_SCOPE_GLOBAL": 1,
}

func (x ScopeType) Enum() *ScopeType {
	p := new(ScopeType)
	*p = x
	return p
}
func (x ScopeType) String() string {
	return proto.EnumName(ScopeType_name, int32(x))
}
func (x *ScopeType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ScopeType_value, data, "ScopeType")
	if err != nil {
		return err
	}
	*x = ScopeType(value)
	return nil
}
func (ScopeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor18, []int{0} }

type FlushDescriptor_FlushAction int32

const (
	FlushDescriptor_START_FLUSH  FlushDescriptor_FlushAction = 0
	FlushDescriptor_COMMIT_FLUSH FlushDescriptor_FlushAction = 1
	FlushDescriptor_ABORT_FLUSH  FlushDescriptor_FlushAction = 2
	FlushDescriptor_CANNOT_FLUSH FlushDescriptor_FlushAction = 3
)

var FlushDescriptor_FlushAction_name = map[int32]string{
	0: "START_FLUSH",
	1: "COMMIT_FLUSH",
	2: "ABORT_FLUSH",
	3: "CANNOT_FLUSH",
}
var FlushDescriptor_FlushAction_value = map[string]int32{
	"START_FLUSH":  0,
	"COMMIT_FLUSH": 1,
	"ABORT_FLUSH":  2,
	"CANNOT_FLUSH": 3,
}

func (x FlushDescriptor_FlushAction) Enum() *FlushDescriptor_FlushAction {
	p := new(FlushDescriptor_FlushAction)
	*p = x
	return p
}
func (x FlushDescriptor_FlushAction) String() string {
	return proto.EnumName(FlushDescriptor_FlushAction_name, int32(x))
}
func (x *FlushDescriptor_FlushAction) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(FlushDescriptor_FlushAction_value, data, "FlushDescriptor_FlushAction")
	if err != nil {
		return err
	}
	*x = FlushDescriptor_FlushAction(value)
	return nil
}
func (FlushDescriptor_FlushAction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor18, []int{4, 0}
}

type RegionEventDescriptor_EventType int32

const (
	RegionEventDescriptor_REGION_OPEN  RegionEventDescriptor_EventType = 0
	RegionEventDescriptor_REGION_CLOSE RegionEventDescriptor_EventType = 1
)

var RegionEventDescriptor_EventType_name = map[int32]string{
	0: "REGION_OPEN",
	1: "REGION_CLOSE",
}
var RegionEventDescriptor_EventType_value = map[string]int32{
	"REGION_OPEN":  0,
	"REGION_CLOSE": 1,
}

func (x RegionEventDescriptor_EventType) Enum() *RegionEventDescriptor_EventType {
	p := new(RegionEventDescriptor_EventType)
	*p = x
	return p
}
func (x RegionEventDescriptor_EventType) String() string {
	return proto.EnumName(RegionEventDescriptor_EventType_name, int32(x))
}
func (x *RegionEventDescriptor_EventType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(RegionEventDescriptor_EventType_value, data, "RegionEventDescriptor_EventType")
	if err != nil {
		return err
	}
	*x = RegionEventDescriptor_EventType(value)
	return nil
}
func (RegionEventDescriptor_EventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor18, []int{7, 0}
}

type WALHeader struct {
	HasCompression    *bool   `protobuf:"varint,1,opt,name=has_compression,json=hasCompression" json:"has_compression,omitempty"`
	EncryptionKey     []byte  `protobuf:"bytes,2,opt,name=encryption_key,json=encryptionKey" json:"encryption_key,omitempty"`
	HasTagCompression *bool   `protobuf:"varint,3,opt,name=has_tag_compression,json=hasTagCompression" json:"has_tag_compression,omitempty"`
	WriterClsName     *string `protobuf:"bytes,4,opt,name=writer_cls_name,json=writerClsName" json:"writer_cls_name,omitempty"`
	CellCodecClsName  *string `protobuf:"bytes,5,opt,name=cell_codec_cls_name,json=cellCodecClsName" json:"cell_codec_cls_name,omitempty"`
	XXX_unrecognized  []byte  `json:"-"`
}

func (m *WALHeader) Reset()                    { *m = WALHeader{} }
func (m *WALHeader) String() string            { return proto.CompactTextString(m) }
func (*WALHeader) ProtoMessage()               {}
func (*WALHeader) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{0} }

func (m *WALHeader) GetHasCompression() bool {
	if m != nil && m.HasCompression != nil {
		return *m.HasCompression
	}
	return false
}

func (m *WALHeader) GetEncryptionKey() []byte {
	if m != nil {
		return m.EncryptionKey
	}
	return nil
}

func (m *WALHeader) GetHasTagCompression() bool {
	if m != nil && m.HasTagCompression != nil {
		return *m.HasTagCompression
	}
	return false
}

func (m *WALHeader) GetWriterClsName() string {
	if m != nil && m.WriterClsName != nil {
		return *m.WriterClsName
	}
	return ""
}

func (m *WALHeader) GetCellCodecClsName() string {
	if m != nil && m.CellCodecClsName != nil {
		return *m.CellCodecClsName
	}
	return ""
}

//
// Protocol buffer version of WALKey; see WALKey comment, not really a key but WALEdit header
// for some KVs
type WALKey struct {
	EncodedRegionName []byte  `protobuf:"bytes,1,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
	TableName         []byte  `protobuf:"bytes,2,req,name=table_name,json=tableName" json:"table_name,omitempty"`
	LogSequenceNumber *uint64 `protobuf:"varint,3,req,name=log_sequence_number,json=logSequenceNumber" json:"log_sequence_number,omitempty"`
	WriteTime         *uint64 `protobuf:"varint,4,req,name=write_time,json=writeTime" json:"write_time,omitempty"`
	//
	// This parameter is deprecated in favor of clusters which
	// contains the list of clusters that have consumed the change.
	// It is retained so that the log created by earlier releases (0.94)
	// can be read by the newer releases.
	ClusterId        *UUID          `protobuf:"bytes,5,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"`
	Scopes           []*FamilyScope `protobuf:"bytes,6,rep,name=scopes" json:"scopes,omitempty"`
	FollowingKvCount *uint32        `protobuf:"varint,7,opt,name=following_kv_count,json=followingKvCount" json:"following_kv_count,omitempty"`
	//
	// This field contains the list of clusters that have
	// consumed the change
	ClusterIds         []*UUID `protobuf:"bytes,8,rep,name=cluster_ids,json=clusterIds" json:"cluster_ids,omitempty"`
	NonceGroup         *uint64 `protobuf:"varint,9,opt,name=nonceGroup" json:"nonceGroup,omitempty"`
	Nonce              *uint64 `protobuf:"varint,10,opt,name=nonce" json:"nonce,omitempty"`
	OrigSequenceNumber *uint64 `protobuf:"varint,11,opt,name=orig_sequence_number,json=origSequenceNumber" json:"orig_sequence_number,omitempty"`
	XXX_unrecognized   []byte  `json:"-"`
}

func (m *WALKey) Reset()                    { *m = WALKey{} }
func (m *WALKey) String() string            { return proto.CompactTextString(m) }
func (*WALKey) ProtoMessage()               {}
func (*WALKey) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{1} }

func (m *WALKey) GetEncodedRegionName() []byte {
	if m != nil {
		return m.EncodedRegionName
	}
	return nil
}

func (m *WALKey) GetTableName() []byte {
	if m != nil {
		return m.TableName
	}
	return nil
}

func (m *WALKey) GetLogSequenceNumber() uint64 {
	if m != nil && m.LogSequenceNumber != nil {
		return *m.LogSequenceNumber
	}
	return 0
}

func (m *WALKey) GetWriteTime() uint64 {
	if m != nil && m.WriteTime != nil {
		return *m.WriteTime
	}
	return 0
}

func (m *WALKey) GetClusterId() *UUID {
	if m != nil {
		return m.ClusterId
	}
	return nil
}

func (m *WALKey) GetScopes() []*FamilyScope {
	if m != nil {
		return m.Scopes
	}
	return nil
}

func (m *WALKey) GetFollowingKvCount() uint32 {
	if m != nil && m.FollowingKvCount != nil {
		return *m.FollowingKvCount
	}
	return 0
}

func (m *WALKey) GetClusterIds() []*UUID {
	if m != nil {
		return m.ClusterIds
	}
	return nil
}

func (m *WALKey) GetNonceGroup() uint64 {
	if m != nil && m.NonceGroup != nil {
		return *m.NonceGroup
	}
	return 0
}

func (m *WALKey) GetNonce() uint64 {
	if m != nil && m.Nonce != nil {
		return *m.Nonce
	}
	return 0
}

func (m *WALKey) GetOrigSequenceNumber() uint64 {
	if m != nil && m.OrigSequenceNumber != nil {
		return *m.OrigSequenceNumber
	}
	return 0
}

type FamilyScope struct {
	Family           []byte     `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
	ScopeType        *ScopeType `protobuf:"varint,2,req,name=scope_type,json=scopeType,enum=pb.ScopeType" json:"scope_type,omitempty"`
	XXX_unrecognized []byte     `json:"-"`
}

func (m *FamilyScope) Reset()                    { *m = FamilyScope{} }
func (m *FamilyScope) String() string            { return proto.CompactTextString(m) }
func (*FamilyScope) ProtoMessage()               {}
func (*FamilyScope) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{2} }

func (m *FamilyScope) GetFamily() []byte {
	if m != nil {
		return m.Family
	}
	return nil
}

func (m *FamilyScope) GetScopeType() ScopeType {
	if m != nil && m.ScopeType != nil {
		return *m.ScopeType
	}
	return ScopeType_REPLICATION_SCOPE_LOCAL
}

// *
// Special WAL entry to hold all related to a compaction.
// Written to WAL before completing compaction.  There is
// sufficient info in the below message to complete later
// the * compaction should we fail the WAL write.
type CompactionDescriptor struct {
	TableName         []byte   `protobuf:"bytes,1,req,name=table_name,json=tableName" json:"table_name,omitempty"`
	EncodedRegionName []byte   `protobuf:"bytes,2,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
	FamilyName        []byte   `protobuf:"bytes,3,req,name=family_name,json=familyName" json:"family_name,omitempty"`
	CompactionInput   []string `protobuf:"bytes,4,rep,name=compaction_input,json=compactionInput" json:"compaction_input,omitempty"`
	CompactionOutput  []string `protobuf:"bytes,5,rep,name=compaction_output,json=compactionOutput" json:"compaction_output,omitempty"`
	StoreHomeDir      *string  `protobuf:"bytes,6,req,name=store_home_dir,json=storeHomeDir" json:"store_home_dir,omitempty"`
	RegionName        []byte   `protobuf:"bytes,7,opt,name=region_name,json=regionName" json:"region_name,omitempty"`
	XXX_unrecognized  []byte   `json:"-"`
}

func (m *CompactionDescriptor) Reset()                    { *m = CompactionDescriptor{} }
func (m *CompactionDescriptor) String() string            { return proto.CompactTextString(m) }
func (*CompactionDescriptor) ProtoMessage()               {}
func (*CompactionDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{3} }

func (m *CompactionDescriptor) GetTableName() []byte {
	if m != nil {
		return m.TableName
	}
	return nil
}

func (m *CompactionDescriptor) GetEncodedRegionName() []byte {
	if m != nil {
		return m.EncodedRegionName
	}
	return nil
}

func (m *CompactionDescriptor) GetFamilyName() []byte {
	if m != nil {
		return m.FamilyName
	}
	return nil
}

func (m *CompactionDescriptor) GetCompactionInput() []string {
	if m != nil {
		return m.CompactionInput
	}
	return nil
}

func (m *CompactionDescriptor) GetCompactionOutput() []string {
	if m != nil {
		return m.CompactionOutput
	}
	return nil
}

func (m *CompactionDescriptor) GetStoreHomeDir() string {
	if m != nil && m.StoreHomeDir != nil {
		return *m.StoreHomeDir
	}
	return ""
}

func (m *CompactionDescriptor) GetRegionName() []byte {
	if m != nil {
		return m.RegionName
	}
	return nil
}

// *
// Special WAL entry to hold all related to a flush.
type FlushDescriptor struct {
	Action              *FlushDescriptor_FlushAction            `protobuf:"varint,1,req,name=action,enum=pb.FlushDescriptor_FlushAction" json:"action,omitempty"`
	TableName           []byte                                  `protobuf:"bytes,2,req,name=table_name,json=tableName" json:"table_name,omitempty"`
	EncodedRegionName   []byte                                  `protobuf:"bytes,3,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
	FlushSequenceNumber *uint64                                 `protobuf:"varint,4,opt,name=flush_sequence_number,json=flushSequenceNumber" json:"flush_sequence_number,omitempty"`
	StoreFlushes        []*FlushDescriptor_StoreFlushDescriptor `protobuf:"bytes,5,rep,name=store_flushes,json=storeFlushes" json:"store_flushes,omitempty"`
	RegionName          []byte                                  `protobuf:"bytes,6,opt,name=region_name,json=regionName" json:"region_name,omitempty"`
	XXX_unrecognized    []byte                                  `json:"-"`
}

func (m *FlushDescriptor) Reset()                    { *m = FlushDescriptor{} }
func (m *FlushDescriptor) String() string            { return proto.CompactTextString(m) }
func (*FlushDescriptor) ProtoMessage()               {}
func (*FlushDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{4} }

func (m *FlushDescriptor) GetAction() FlushDescriptor_FlushAction {
	if m != nil && m.Action != nil {
		return *m.Action
	}
	return FlushDescriptor_START_FLUSH
}

func (m *FlushDescriptor) GetTableName() []byte {
	if m != nil {
		return m.TableName
	}
	return nil
}

func (m *FlushDescriptor) GetEncodedRegionName() []byte {
	if m != nil {
		return m.EncodedRegionName
	}
	return nil
}

func (m *FlushDescriptor) GetFlushSequenceNumber() uint64 {
	if m != nil && m.FlushSequenceNumber != nil {
		return *m.FlushSequenceNumber
	}
	return 0
}

func (m *FlushDescriptor) GetStoreFlushes() []*FlushDescriptor_StoreFlushDescriptor {
	if m != nil {
		return m.StoreFlushes
	}
	return nil
}

func (m *FlushDescriptor) GetRegionName() []byte {
	if m != nil {
		return m.RegionName
	}
	return nil
}

type FlushDescriptor_StoreFlushDescriptor struct {
	FamilyName       []byte   `protobuf:"bytes,1,req,name=family_name,json=familyName" json:"family_name,omitempty"`
	StoreHomeDir     *string  `protobuf:"bytes,2,req,name=store_home_dir,json=storeHomeDir" json:"store_home_dir,omitempty"`
	FlushOutput      []string `protobuf:"bytes,3,rep,name=flush_output,json=flushOutput" json:"flush_output,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *FlushDescriptor_StoreFlushDescriptor) Reset()         { *m = FlushDescriptor_StoreFlushDescriptor{} }
func (m *FlushDescriptor_StoreFlushDescriptor) String() string { return proto.CompactTextString(m) }
func (*FlushDescriptor_StoreFlushDescriptor) ProtoMessage()    {}
func (*FlushDescriptor_StoreFlushDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor18, []int{4, 0}
}

func (m *FlushDescriptor_StoreFlushDescriptor) GetFamilyName() []byte {
	if m != nil {
		return m.FamilyName
	}
	return nil
}

func (m *FlushDescriptor_StoreFlushDescriptor) GetStoreHomeDir() string {
	if m != nil && m.StoreHomeDir != nil {
		return *m.StoreHomeDir
	}
	return ""
}

func (m *FlushDescriptor_StoreFlushDescriptor) GetFlushOutput() []string {
	if m != nil {
		return m.FlushOutput
	}
	return nil
}

type StoreDescriptor struct {
	FamilyName         []byte   `protobuf:"bytes,1,req,name=family_name,json=familyName" json:"family_name,omitempty"`
	StoreHomeDir       *string  `protobuf:"bytes,2,req,name=store_home_dir,json=storeHomeDir" json:"store_home_dir,omitempty"`
	StoreFile          []string `protobuf:"bytes,3,rep,name=store_file,json=storeFile" json:"store_file,omitempty"`
	StoreFileSizeBytes *uint64  `protobuf:"varint,4,opt,name=store_file_size_bytes,json=storeFileSizeBytes" json:"store_file_size_bytes,omitempty"`
	XXX_unrecognized   []byte   `json:"-"`
}

func (m *StoreDescriptor) Reset()                    { *m = StoreDescriptor{} }
func (m *StoreDescriptor) String() string            { return proto.CompactTextString(m) }
func (*StoreDescriptor) ProtoMessage()               {}
func (*StoreDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{5} }

func (m *StoreDescriptor) GetFamilyName() []byte {
	if m != nil {
		return m.FamilyName
	}
	return nil
}

func (m *StoreDescriptor) GetStoreHomeDir() string {
	if m != nil && m.StoreHomeDir != nil {
		return *m.StoreHomeDir
	}
	return ""
}

func (m *StoreDescriptor) GetStoreFile() []string {
	if m != nil {
		return m.StoreFile
	}
	return nil
}

func (m *StoreDescriptor) GetStoreFileSizeBytes() uint64 {
	if m != nil && m.StoreFileSizeBytes != nil {
		return *m.StoreFileSizeBytes
	}
	return 0
}

// *
// Special WAL entry used for writing bulk load events to WAL
type BulkLoadDescriptor struct {
	TableName         *TableName         `protobuf:"bytes,1,req,name=table_name,json=tableName" json:"table_name,omitempty"`
	EncodedRegionName []byte             `protobuf:"bytes,2,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
	Stores            []*StoreDescriptor `protobuf:"bytes,3,rep,name=stores" json:"stores,omitempty"`
	BulkloadSeqNum    *int64             `protobuf:"varint,4,req,name=bulkload_seq_num,json=bulkloadSeqNum" json:"bulkload_seq_num,omitempty"`
	XXX_unrecognized  []byte             `json:"-"`
}

func (m *BulkLoadDescriptor) Reset()                    { *m = BulkLoadDescriptor{} }
func (m *BulkLoadDescriptor) String() string            { return proto.CompactTextString(m) }
func (*BulkLoadDescriptor) ProtoMessage()               {}
func (*BulkLoadDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{6} }

func (m *BulkLoadDescriptor) GetTableName() *TableName {
	if m != nil {
		return m.TableName
	}
	return nil
}

func (m *BulkLoadDescriptor) GetEncodedRegionName() []byte {
	if m != nil {
		return m.EncodedRegionName
	}
	return nil
}

func (m *BulkLoadDescriptor) GetStores() []*StoreDescriptor {
	if m != nil {
		return m.Stores
	}
	return nil
}

func (m *BulkLoadDescriptor) GetBulkloadSeqNum() int64 {
	if m != nil && m.BulkloadSeqNum != nil {
		return *m.BulkloadSeqNum
	}
	return 0
}

// *
// Special WAL entry to hold all related to a region event (open/close).
type RegionEventDescriptor struct {
	EventType         *RegionEventDescriptor_EventType `protobuf:"varint,1,req,name=event_type,json=eventType,enum=pb.RegionEventDescriptor_EventType" json:"event_type,omitempty"`
	TableName         []byte                           `protobuf:"bytes,2,req,name=table_name,json=tableName" json:"table_name,omitempty"`
	EncodedRegionName []byte                           `protobuf:"bytes,3,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
	LogSequenceNumber *uint64                          `protobuf:"varint,4,opt,name=log_sequence_number,json=logSequenceNumber" json:"log_sequence_number,omitempty"`
	Stores            []*StoreDescriptor               `protobuf:"bytes,5,rep,name=stores" json:"stores,omitempty"`
	Server            *ServerName                      `protobuf:"bytes,6,opt,name=server" json:"server,omitempty"`
	RegionName        []byte                           `protobuf:"bytes,7,opt,name=region_name,json=regionName" json:"region_name,omitempty"`
	XXX_unrecognized  []byte                           `json:"-"`
}

func (m *RegionEventDescriptor) Reset()                    { *m = RegionEventDescriptor{} }
func (m *RegionEventDescriptor) String() string            { return proto.CompactTextString(m) }
func (*RegionEventDescriptor) ProtoMessage()               {}
func (*RegionEventDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{7} }

func (m *RegionEventDescriptor) GetEventType() RegionEventDescriptor_EventType {
	if m != nil && m.EventType != nil {
		return *m.EventType
	}
	return RegionEventDescriptor_REGION_OPEN
}

func (m *RegionEventDescriptor) GetTableName() []byte {
	if m != nil {
		return m.TableName
	}
	return nil
}

func (m *RegionEventDescriptor) GetEncodedRegionName() []byte {
	if m != nil {
		return m.EncodedRegionName
	}
	return nil
}

func (m *RegionEventDescriptor) GetLogSequenceNumber() uint64 {
	if m != nil && m.LogSequenceNumber != nil {
		return *m.LogSequenceNumber
	}
	return 0
}

func (m *RegionEventDescriptor) GetStores() []*StoreDescriptor {
	if m != nil {
		return m.Stores
	}
	return nil
}

func (m *RegionEventDescriptor) GetServer() *ServerName {
	if m != nil {
		return m.Server
	}
	return nil
}

func (m *RegionEventDescriptor) GetRegionName() []byte {
	if m != nil {
		return m.RegionName
	}
	return nil
}

// *
// A trailer that is appended to the end of a properly closed WAL file.
// If missing, this is either a legacy or a corrupted WAL file.
// N.B. This trailer currently doesn't contain any information and we
// purposefully don't expose it in the WAL APIs. It's for future growth.
type WALTrailer struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *WALTrailer) Reset()                    { *m = WALTrailer{} }
func (m *WALTrailer) String() string            { return proto.CompactTextString(m) }
func (*WALTrailer) ProtoMessage()               {}
func (*WALTrailer) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{8} }

func init() {
	proto.RegisterType((*WALHeader)(nil), "pb.WALHeader")
	proto.RegisterType((*WALKey)(nil), "pb.WALKey")
	proto.RegisterType((*FamilyScope)(nil), "pb.FamilyScope")
	proto.RegisterType((*CompactionDescriptor)(nil), "pb.CompactionDescriptor")
	proto.RegisterType((*FlushDescriptor)(nil), "pb.FlushDescriptor")
	proto.RegisterType((*FlushDescriptor_StoreFlushDescriptor)(nil), "pb.FlushDescriptor.StoreFlushDescriptor")
	proto.RegisterType((*StoreDescriptor)(nil), "pb.StoreDescriptor")
	proto.RegisterType((*BulkLoadDescriptor)(nil), "pb.BulkLoadDescriptor")
	proto.RegisterType((*RegionEventDescriptor)(nil), "pb.RegionEventDescriptor")
	proto.RegisterType((*WALTrailer)(nil), "pb.WALTrailer")
	proto.RegisterEnum("pb.ScopeType", ScopeType_name, ScopeType_value)
	proto.RegisterEnum("pb.FlushDescriptor_FlushAction", FlushDescriptor_FlushAction_name, FlushDescriptor_FlushAction_value)
	proto.RegisterEnum("pb.RegionEventDescriptor_EventType", RegionEventDescriptor_EventType_name, RegionEventDescriptor_EventType_value)
}

func init() { proto.RegisterFile("WAL.proto", fileDescriptor18) }

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