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

package proto

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

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

type GetRegionInfoResponse_CompactionState int32

const (
	GetRegionInfoResponse_NONE            GetRegionInfoResponse_CompactionState = 0
	GetRegionInfoResponse_MINOR           GetRegionInfoResponse_CompactionState = 1
	GetRegionInfoResponse_MAJOR           GetRegionInfoResponse_CompactionState = 2
	GetRegionInfoResponse_MAJOR_AND_MINOR GetRegionInfoResponse_CompactionState = 3
)

var GetRegionInfoResponse_CompactionState_name = map[int32]string{
	0: "NONE",
	1: "MINOR",
	2: "MAJOR",
	3: "MAJOR_AND_MINOR",
}
var GetRegionInfoResponse_CompactionState_value = map[string]int32{
	"NONE":            0,
	"MINOR":           1,
	"MAJOR":           2,
	"MAJOR_AND_MINOR": 3,
}

func (x GetRegionInfoResponse_CompactionState) Enum() *GetRegionInfoResponse_CompactionState {
	p := new(GetRegionInfoResponse_CompactionState)
	*p = x
	return p
}
func (x GetRegionInfoResponse_CompactionState) String() string {
	return proto1.EnumName(GetRegionInfoResponse_CompactionState_name, int32(x))
}
func (x *GetRegionInfoResponse_CompactionState) UnmarshalJSON(data []byte) error {
	value, err := proto1.UnmarshalJSONEnum(GetRegionInfoResponse_CompactionState_value, data, "GetRegionInfoResponse_CompactionState")
	if err != nil {
		return err
	}
	*x = GetRegionInfoResponse_CompactionState(value)
	return nil
}

type OpenRegionResponse_RegionOpeningState int32

const (
	OpenRegionResponse_OPENED         OpenRegionResponse_RegionOpeningState = 0
	OpenRegionResponse_ALREADY_OPENED OpenRegionResponse_RegionOpeningState = 1
	OpenRegionResponse_FAILED_OPENING OpenRegionResponse_RegionOpeningState = 2
)

var OpenRegionResponse_RegionOpeningState_name = map[int32]string{
	0: "OPENED",
	1: "ALREADY_OPENED",
	2: "FAILED_OPENING",
}
var OpenRegionResponse_RegionOpeningState_value = map[string]int32{
	"OPENED":         0,
	"ALREADY_OPENED": 1,
	"FAILED_OPENING": 2,
}

func (x OpenRegionResponse_RegionOpeningState) Enum() *OpenRegionResponse_RegionOpeningState {
	p := new(OpenRegionResponse_RegionOpeningState)
	*p = x
	return p
}
func (x OpenRegionResponse_RegionOpeningState) String() string {
	return proto1.EnumName(OpenRegionResponse_RegionOpeningState_name, int32(x))
}
func (x *OpenRegionResponse_RegionOpeningState) UnmarshalJSON(data []byte) error {
	value, err := proto1.UnmarshalJSONEnum(OpenRegionResponse_RegionOpeningState_value, data, "OpenRegionResponse_RegionOpeningState")
	if err != nil {
		return err
	}
	*x = OpenRegionResponse_RegionOpeningState(value)
	return nil
}

type GetRegionInfoRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	CompactionState  *bool            `protobuf:"varint,2,opt,name=compaction_state" json:"compaction_state,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *GetRegionInfoRequest) Reset()         { *m = GetRegionInfoRequest{} }
func (m *GetRegionInfoRequest) String() string { return proto1.CompactTextString(m) }
func (*GetRegionInfoRequest) ProtoMessage()    {}

func (m *GetRegionInfoRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *GetRegionInfoRequest) GetCompactionState() bool {
	if m != nil && m.CompactionState != nil {
		return *m.CompactionState
	}
	return false
}

type GetRegionInfoResponse struct {
	RegionInfo       *RegionInfo                            `protobuf:"bytes,1,req,name=region_info" json:"region_info,omitempty"`
	CompactionState  *GetRegionInfoResponse_CompactionState `protobuf:"varint,2,opt,name=compaction_state,enum=proto.GetRegionInfoResponse_CompactionState" json:"compaction_state,omitempty"`
	IsRecovering     *bool                                  `protobuf:"varint,3,opt,name=isRecovering" json:"isRecovering,omitempty"`
	XXX_unrecognized []byte                                 `json:"-"`
}

func (m *GetRegionInfoResponse) Reset()         { *m = GetRegionInfoResponse{} }
func (m *GetRegionInfoResponse) String() string { return proto1.CompactTextString(m) }
func (*GetRegionInfoResponse) ProtoMessage()    {}

func (m *GetRegionInfoResponse) GetRegionInfo() *RegionInfo {
	if m != nil {
		return m.RegionInfo
	}
	return nil
}

func (m *GetRegionInfoResponse) GetCompactionState() GetRegionInfoResponse_CompactionState {
	if m != nil && m.CompactionState != nil {
		return *m.CompactionState
	}
	return GetRegionInfoResponse_NONE
}

func (m *GetRegionInfoResponse) GetIsRecovering() bool {
	if m != nil && m.IsRecovering != nil {
		return *m.IsRecovering
	}
	return false
}

// *
// Get a list of store files for a set of column families in a particular region.
// If no column family is specified, get the store files for all column families.
type GetStoreFileRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	Family           [][]byte         `protobuf:"bytes,2,rep,name=family" json:"family,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *GetStoreFileRequest) Reset()         { *m = GetStoreFileRequest{} }
func (m *GetStoreFileRequest) String() string { return proto1.CompactTextString(m) }
func (*GetStoreFileRequest) ProtoMessage()    {}

func (m *GetStoreFileRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

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

type GetStoreFileResponse struct {
	StoreFile        []string `protobuf:"bytes,1,rep,name=store_file" json:"store_file,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *GetStoreFileResponse) Reset()         { *m = GetStoreFileResponse{} }
func (m *GetStoreFileResponse) String() string { return proto1.CompactTextString(m) }
func (*GetStoreFileResponse) ProtoMessage()    {}

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

type GetOnlineRegionRequest struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *GetOnlineRegionRequest) Reset()         { *m = GetOnlineRegionRequest{} }
func (m *GetOnlineRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*GetOnlineRegionRequest) ProtoMessage()    {}

type GetOnlineRegionResponse struct {
	RegionInfo       []*RegionInfo `protobuf:"bytes,1,rep,name=region_info" json:"region_info,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

func (m *GetOnlineRegionResponse) Reset()         { *m = GetOnlineRegionResponse{} }
func (m *GetOnlineRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*GetOnlineRegionResponse) ProtoMessage()    {}

func (m *GetOnlineRegionResponse) GetRegionInfo() []*RegionInfo {
	if m != nil {
		return m.RegionInfo
	}
	return nil
}

type OpenRegionRequest struct {
	OpenInfo []*OpenRegionRequest_RegionOpenInfo `protobuf:"bytes,1,rep,name=open_info" json:"open_info,omitempty"`
	// the intended server for this RPC.
	ServerStartCode  *uint64 `protobuf:"varint,2,opt,name=serverStartCode" json:"serverStartCode,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *OpenRegionRequest) Reset()         { *m = OpenRegionRequest{} }
func (m *OpenRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*OpenRegionRequest) ProtoMessage()    {}

func (m *OpenRegionRequest) GetOpenInfo() []*OpenRegionRequest_RegionOpenInfo {
	if m != nil {
		return m.OpenInfo
	}
	return nil
}

func (m *OpenRegionRequest) GetServerStartCode() uint64 {
	if m != nil && m.ServerStartCode != nil {
		return *m.ServerStartCode
	}
	return 0
}

type OpenRegionRequest_RegionOpenInfo struct {
	Region               *RegionInfo   `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	VersionOfOfflineNode *uint32       `protobuf:"varint,2,opt,name=version_of_offline_node" json:"version_of_offline_node,omitempty"`
	FavoredNodes         []*ServerName `protobuf:"bytes,3,rep,name=favored_nodes" json:"favored_nodes,omitempty"`
	// open region for distributedLogReplay
	OpenForDistributedLogReplay *bool  `protobuf:"varint,4,opt,name=openForDistributedLogReplay" json:"openForDistributedLogReplay,omitempty"`
	XXX_unrecognized            []byte `json:"-"`
}

func (m *OpenRegionRequest_RegionOpenInfo) Reset()         { *m = OpenRegionRequest_RegionOpenInfo{} }
func (m *OpenRegionRequest_RegionOpenInfo) String() string { return proto1.CompactTextString(m) }
func (*OpenRegionRequest_RegionOpenInfo) ProtoMessage()    {}

func (m *OpenRegionRequest_RegionOpenInfo) GetRegion() *RegionInfo {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *OpenRegionRequest_RegionOpenInfo) GetVersionOfOfflineNode() uint32 {
	if m != nil && m.VersionOfOfflineNode != nil {
		return *m.VersionOfOfflineNode
	}
	return 0
}

func (m *OpenRegionRequest_RegionOpenInfo) GetFavoredNodes() []*ServerName {
	if m != nil {
		return m.FavoredNodes
	}
	return nil
}

func (m *OpenRegionRequest_RegionOpenInfo) GetOpenForDistributedLogReplay() bool {
	if m != nil && m.OpenForDistributedLogReplay != nil {
		return *m.OpenForDistributedLogReplay
	}
	return false
}

type OpenRegionResponse struct {
	OpeningState     []OpenRegionResponse_RegionOpeningState `protobuf:"varint,1,rep,name=opening_state,enum=proto.OpenRegionResponse_RegionOpeningState" json:"opening_state,omitempty"`
	XXX_unrecognized []byte                                  `json:"-"`
}

func (m *OpenRegionResponse) Reset()         { *m = OpenRegionResponse{} }
func (m *OpenRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*OpenRegionResponse) ProtoMessage()    {}

func (m *OpenRegionResponse) GetOpeningState() []OpenRegionResponse_RegionOpeningState {
	if m != nil {
		return m.OpeningState
	}
	return nil
}

// *
// Closes the specified region and will use or not use ZK during the close
// according to the specified flag.
type CloseRegionRequest struct {
	Region               *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	VersionOfClosingNode *uint32          `protobuf:"varint,2,opt,name=version_of_closing_node" json:"version_of_closing_node,omitempty"`
	TransitionIn_ZK      *bool            `protobuf:"varint,3,opt,name=transition_in_ZK,def=1" json:"transition_in_ZK,omitempty"`
	DestinationServer    *ServerName      `protobuf:"bytes,4,opt,name=destination_server" json:"destination_server,omitempty"`
	// the intended server for this RPC.
	ServerStartCode  *uint64 `protobuf:"varint,5,opt,name=serverStartCode" json:"serverStartCode,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CloseRegionRequest) Reset()         { *m = CloseRegionRequest{} }
func (m *CloseRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*CloseRegionRequest) ProtoMessage()    {}

const Default_CloseRegionRequest_TransitionIn_ZK bool = true

func (m *CloseRegionRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *CloseRegionRequest) GetVersionOfClosingNode() uint32 {
	if m != nil && m.VersionOfClosingNode != nil {
		return *m.VersionOfClosingNode
	}
	return 0
}

func (m *CloseRegionRequest) GetTransitionIn_ZK() bool {
	if m != nil && m.TransitionIn_ZK != nil {
		return *m.TransitionIn_ZK
	}
	return Default_CloseRegionRequest_TransitionIn_ZK
}

func (m *CloseRegionRequest) GetDestinationServer() *ServerName {
	if m != nil {
		return m.DestinationServer
	}
	return nil
}

func (m *CloseRegionRequest) GetServerStartCode() uint64 {
	if m != nil && m.ServerStartCode != nil {
		return *m.ServerStartCode
	}
	return 0
}

type CloseRegionResponse struct {
	Closed           *bool  `protobuf:"varint,1,req,name=closed" json:"closed,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *CloseRegionResponse) Reset()         { *m = CloseRegionResponse{} }
func (m *CloseRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*CloseRegionResponse) ProtoMessage()    {}

func (m *CloseRegionResponse) GetClosed() bool {
	if m != nil && m.Closed != nil {
		return *m.Closed
	}
	return false
}

// *
// Flushes the MemStore of the specified region.
// <p>
// This method is synchronous.
type FlushRegionRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	IfOlderThanTs    *uint64          `protobuf:"varint,2,opt,name=if_older_than_ts" json:"if_older_than_ts,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *FlushRegionRequest) Reset()         { *m = FlushRegionRequest{} }
func (m *FlushRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*FlushRegionRequest) ProtoMessage()    {}

func (m *FlushRegionRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *FlushRegionRequest) GetIfOlderThanTs() uint64 {
	if m != nil && m.IfOlderThanTs != nil {
		return *m.IfOlderThanTs
	}
	return 0
}

type FlushRegionResponse struct {
	LastFlushTime    *uint64 `protobuf:"varint,1,req,name=last_flush_time" json:"last_flush_time,omitempty"`
	Flushed          *bool   `protobuf:"varint,2,opt,name=flushed" json:"flushed,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *FlushRegionResponse) Reset()         { *m = FlushRegionResponse{} }
func (m *FlushRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*FlushRegionResponse) ProtoMessage()    {}

func (m *FlushRegionResponse) GetLastFlushTime() uint64 {
	if m != nil && m.LastFlushTime != nil {
		return *m.LastFlushTime
	}
	return 0
}

func (m *FlushRegionResponse) GetFlushed() bool {
	if m != nil && m.Flushed != nil {
		return *m.Flushed
	}
	return false
}

// *
// Splits the specified region.
// <p>
// This method currently flushes the region and then forces a compaction which
// will then trigger a split.  The flush is done synchronously but the
// compaction is asynchronous.
type SplitRegionRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	SplitPoint       []byte           `protobuf:"bytes,2,opt,name=split_point" json:"split_point,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *SplitRegionRequest) Reset()         { *m = SplitRegionRequest{} }
func (m *SplitRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*SplitRegionRequest) ProtoMessage()    {}

func (m *SplitRegionRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *SplitRegionRequest) GetSplitPoint() []byte {
	if m != nil {
		return m.SplitPoint
	}
	return nil
}

type SplitRegionResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *SplitRegionResponse) Reset()         { *m = SplitRegionResponse{} }
func (m *SplitRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*SplitRegionResponse) ProtoMessage()    {}

// *
// Compacts the specified region.  Performs a major compaction if specified.
// <p>
// This method is asynchronous.
type CompactRegionRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	Major            *bool            `protobuf:"varint,2,opt,name=major" json:"major,omitempty"`
	Family           []byte           `protobuf:"bytes,3,opt,name=family" json:"family,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *CompactRegionRequest) Reset()         { *m = CompactRegionRequest{} }
func (m *CompactRegionRequest) String() string { return proto1.CompactTextString(m) }
func (*CompactRegionRequest) ProtoMessage()    {}

func (m *CompactRegionRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *CompactRegionRequest) GetMajor() bool {
	if m != nil && m.Major != nil {
		return *m.Major
	}
	return false
}

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

type CompactRegionResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *CompactRegionResponse) Reset()         { *m = CompactRegionResponse{} }
func (m *CompactRegionResponse) String() string { return proto1.CompactTextString(m) }
func (*CompactRegionResponse) ProtoMessage()    {}

type UpdateFavoredNodesRequest struct {
	UpdateInfo       []*UpdateFavoredNodesRequest_RegionUpdateInfo `protobuf:"bytes,1,rep,name=update_info" json:"update_info,omitempty"`
	XXX_unrecognized []byte                                        `json:"-"`
}

func (m *UpdateFavoredNodesRequest) Reset()         { *m = UpdateFavoredNodesRequest{} }
func (m *UpdateFavoredNodesRequest) String() string { return proto1.CompactTextString(m) }
func (*UpdateFavoredNodesRequest) ProtoMessage()    {}

func (m *UpdateFavoredNodesRequest) GetUpdateInfo() []*UpdateFavoredNodesRequest_RegionUpdateInfo {
	if m != nil {
		return m.UpdateInfo
	}
	return nil
}

type UpdateFavoredNodesRequest_RegionUpdateInfo struct {
	Region           *RegionInfo   `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	FavoredNodes     []*ServerName `protobuf:"bytes,2,rep,name=favored_nodes" json:"favored_nodes,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) Reset() {
	*m = UpdateFavoredNodesRequest_RegionUpdateInfo{}
}
func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) String() string {
	return proto1.CompactTextString(m)
}
func (*UpdateFavoredNodesRequest_RegionUpdateInfo) ProtoMessage() {}

func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) GetRegion() *RegionInfo {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) GetFavoredNodes() []*ServerName {
	if m != nil {
		return m.FavoredNodes
	}
	return nil
}

type UpdateFavoredNodesResponse struct {
	Response         *uint32 `protobuf:"varint,1,opt,name=response" json:"response,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *UpdateFavoredNodesResponse) Reset()         { *m = UpdateFavoredNodesResponse{} }
func (m *UpdateFavoredNodesResponse) String() string { return proto1.CompactTextString(m) }
func (*UpdateFavoredNodesResponse) ProtoMessage()    {}

func (m *UpdateFavoredNodesResponse) GetResponse() uint32 {
	if m != nil && m.Response != nil {
		return *m.Response
	}
	return 0
}

// *
// Merges the specified regions.
// <p>
// This method currently closes the regions and then merges them
type MergeRegionsRequest struct {
	RegionA          *RegionSpecifier `protobuf:"bytes,1,req,name=region_a" json:"region_a,omitempty"`
	RegionB          *RegionSpecifier `protobuf:"bytes,2,req,name=region_b" json:"region_b,omitempty"`
	Forcible         *bool            `protobuf:"varint,3,opt,name=forcible,def=0" json:"forcible,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *MergeRegionsRequest) Reset()         { *m = MergeRegionsRequest{} }
func (m *MergeRegionsRequest) String() string { return proto1.CompactTextString(m) }
func (*MergeRegionsRequest) ProtoMessage()    {}

const Default_MergeRegionsRequest_Forcible bool = false

func (m *MergeRegionsRequest) GetRegionA() *RegionSpecifier {
	if m != nil {
		return m.RegionA
	}
	return nil
}

func (m *MergeRegionsRequest) GetRegionB() *RegionSpecifier {
	if m != nil {
		return m.RegionB
	}
	return nil
}

func (m *MergeRegionsRequest) GetForcible() bool {
	if m != nil && m.Forcible != nil {
		return *m.Forcible
	}
	return Default_MergeRegionsRequest_Forcible
}

type MergeRegionsResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *MergeRegionsResponse) Reset()         { *m = MergeRegionsResponse{} }
func (m *MergeRegionsResponse) String() string { return proto1.CompactTextString(m) }
func (*MergeRegionsResponse) ProtoMessage()    {}

// Protocol buffer version of WAL for replication
type WALEntry struct {
	Key *WALKey `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
	// Following may be null if the KVs/Cells are carried along the side in a cellblock (See
	// RPC for more on cellblocks). If Cells/KVs are in a cellblock, this next field is null
	// and associated_cell_count has count of Cells associated w/ this WALEntry
	KeyValueBytes [][]byte `protobuf:"bytes,2,rep,name=key_value_bytes" json:"key_value_bytes,omitempty"`
	// If Cell data is carried alongside in a cellblock, this is count of Cells in the cellblock.
	AssociatedCellCount *int32 `protobuf:"varint,3,opt,name=associated_cell_count" json:"associated_cell_count,omitempty"`
	XXX_unrecognized    []byte `json:"-"`
}

func (m *WALEntry) Reset()         { *m = WALEntry{} }
func (m *WALEntry) String() string { return proto1.CompactTextString(m) }
func (*WALEntry) ProtoMessage()    {}

func (m *WALEntry) GetKey() *WALKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *WALEntry) GetKeyValueBytes() [][]byte {
	if m != nil {
		return m.KeyValueBytes
	}
	return nil
}

func (m *WALEntry) GetAssociatedCellCount() int32 {
	if m != nil && m.AssociatedCellCount != nil {
		return *m.AssociatedCellCount
	}
	return 0
}

// *
// Replicates the given entries. The guarantee is that the given entries
// will be durable on the slave cluster if this method returns without
// any exception.  hbase.replication has to be set to true for this to work.
type ReplicateWALEntryRequest struct {
	Entry            []*WALEntry `protobuf:"bytes,1,rep,name=entry" json:"entry,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *ReplicateWALEntryRequest) Reset()         { *m = ReplicateWALEntryRequest{} }
func (m *ReplicateWALEntryRequest) String() string { return proto1.CompactTextString(m) }
func (*ReplicateWALEntryRequest) ProtoMessage()    {}

func (m *ReplicateWALEntryRequest) GetEntry() []*WALEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

type ReplicateWALEntryResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *ReplicateWALEntryResponse) Reset()         { *m = ReplicateWALEntryResponse{} }
func (m *ReplicateWALEntryResponse) String() string { return proto1.CompactTextString(m) }
func (*ReplicateWALEntryResponse) ProtoMessage()    {}

type RollWALWriterRequest struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *RollWALWriterRequest) Reset()         { *m = RollWALWriterRequest{} }
func (m *RollWALWriterRequest) String() string { return proto1.CompactTextString(m) }
func (*RollWALWriterRequest) ProtoMessage()    {}

type RollWALWriterResponse struct {
	// A list of encoded name of regions to flush
	RegionToFlush    [][]byte `protobuf:"bytes,1,rep,name=region_to_flush" json:"region_to_flush,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *RollWALWriterResponse) Reset()         { *m = RollWALWriterResponse{} }
func (m *RollWALWriterResponse) String() string { return proto1.CompactTextString(m) }
func (*RollWALWriterResponse) ProtoMessage()    {}

func (m *RollWALWriterResponse) GetRegionToFlush() [][]byte {
	if m != nil {
		return m.RegionToFlush
	}
	return nil
}

type StopServerRequest struct {
	Reason           *string `protobuf:"bytes,1,req,name=reason" json:"reason,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *StopServerRequest) Reset()         { *m = StopServerRequest{} }
func (m *StopServerRequest) String() string { return proto1.CompactTextString(m) }
func (*StopServerRequest) ProtoMessage()    {}

func (m *StopServerRequest) GetReason() string {
	if m != nil && m.Reason != nil {
		return *m.Reason
	}
	return ""
}

type StopServerResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *StopServerResponse) Reset()         { *m = StopServerResponse{} }
func (m *StopServerResponse) String() string { return proto1.CompactTextString(m) }
func (*StopServerResponse) ProtoMessage()    {}

type GetServerInfoRequest struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *GetServerInfoRequest) Reset()         { *m = GetServerInfoRequest{} }
func (m *GetServerInfoRequest) String() string { return proto1.CompactTextString(m) }
func (*GetServerInfoRequest) ProtoMessage()    {}

type ServerInfo struct {
	ServerName       *ServerName `protobuf:"bytes,1,req,name=server_name" json:"server_name,omitempty"`
	WebuiPort        *uint32     `protobuf:"varint,2,opt,name=webui_port" json:"webui_port,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *ServerInfo) Reset()         { *m = ServerInfo{} }
func (m *ServerInfo) String() string { return proto1.CompactTextString(m) }
func (*ServerInfo) ProtoMessage()    {}

func (m *ServerInfo) GetServerName() *ServerName {
	if m != nil {
		return m.ServerName
	}
	return nil
}

func (m *ServerInfo) GetWebuiPort() uint32 {
	if m != nil && m.WebuiPort != nil {
		return *m.WebuiPort
	}
	return 0
}

type GetServerInfoResponse struct {
	ServerInfo       *ServerInfo `protobuf:"bytes,1,req,name=server_info" json:"server_info,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *GetServerInfoResponse) Reset()         { *m = GetServerInfoResponse{} }
func (m *GetServerInfoResponse) String() string { return proto1.CompactTextString(m) }
func (*GetServerInfoResponse) ProtoMessage()    {}

func (m *GetServerInfoResponse) GetServerInfo() *ServerInfo {
	if m != nil {
		return m.ServerInfo
	}
	return nil
}

func init() {
	proto1.RegisterEnum("proto.GetRegionInfoResponse_CompactionState", GetRegionInfoResponse_CompactionState_name, GetRegionInfoResponse_CompactionState_value)
	proto1.RegisterEnum("proto.OpenRegionResponse_RegionOpeningState", OpenRegionResponse_RegionOpeningState_name, OpenRegionResponse_RegionOpeningState_value)
}
