meta.pb.go

// Code generated by protoc-gen-gogo.
// source: internal/meta.proto
// DO NOT EDIT!

/*
Package internal is a generated protocol buffer package.

It is generated from these files:
	internal/meta.proto

It has these top-level messages:
	Data
	NodeInfo
	DatabaseInfo
	RetentionPolicyInfo
	ShardGroupInfo
	ShardInfo
	SubscriptionInfo
	ShardOwner
	ContinuousQueryInfo
	UserInfo
	UserPrivilege
	Command
	CreateNodeCommand
	DeleteNodeCommand
	CreateDatabaseCommand
	DropDatabaseCommand
	CreateRetentionPolicyCommand
	DropRetentionPolicyCommand
	SetDefaultRetentionPolicyCommand
	UpdateRetentionPolicyCommand
	CreateShardGroupCommand
	DeleteShardGroupCommand
	CreateContinuousQueryCommand
	DropContinuousQueryCommand
	CreateUserCommand
	DropUserCommand
	UpdateUserCommand
	SetPrivilegeCommand
	SetDataCommand
	SetAdminPrivilegeCommand
	UpdateNodeCommand
	CreateSubscriptionCommand
	DropSubscriptionCommand
	RemovePeerCommand
	CreateMetaNodeCommand
	CreateDataNodeCommand
	UpdateDataNodeCommand
	DeleteMetaNodeCommand
	DeleteDataNodeCommand
	Response
	SetMetaNodeCommand
	DropShardCommand
*/
package internal

import proto "github.com/gogo/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 Command_Type int32

const (
	Command_CreateNodeCommand                Command_Type = 1
	Command_DeleteNodeCommand                Command_Type = 2
	Command_CreateDatabaseCommand            Command_Type = 3
	Command_DropDatabaseCommand              Command_Type = 4
	Command_CreateRetentionPolicyCommand     Command_Type = 5
	Command_DropRetentionPolicyCommand       Command_Type = 6
	Command_SetDefaultRetentionPolicyCommand Command_Type = 7
	Command_UpdateRetentionPolicyCommand     Command_Type = 8
	Command_CreateShardGroupCommand          Command_Type = 9
	Command_DeleteShardGroupCommand          Command_Type = 10
	Command_CreateContinuousQueryCommand     Command_Type = 11
	Command_DropContinuousQueryCommand       Command_Type = 12
	Command_CreateUserCommand                Command_Type = 13
	Command_DropUserCommand                  Command_Type = 14
	Command_UpdateUserCommand                Command_Type = 15
	Command_SetPrivilegeCommand              Command_Type = 16
	Command_SetDataCommand                   Command_Type = 17
	Command_SetAdminPrivilegeCommand         Command_Type = 18
	Command_UpdateNodeCommand                Command_Type = 19
	Command_CreateSubscriptionCommand        Command_Type = 21
	Command_DropSubscriptionCommand          Command_Type = 22
	Command_RemovePeerCommand                Command_Type = 23
	Command_CreateMetaNodeCommand            Command_Type = 24
	Command_CreateDataNodeCommand            Command_Type = 25
	Command_UpdateDataNodeCommand            Command_Type = 26
	Command_DeleteMetaNodeCommand            Command_Type = 27
	Command_DeleteDataNodeCommand            Command_Type = 28
	Command_SetMetaNodeCommand               Command_Type = 29
	Command_DropShardCommand                 Command_Type = 30
)

var Command_Type_name = map[int32]string{
	1:  "CreateNodeCommand",
	2:  "DeleteNodeCommand",
	3:  "CreateDatabaseCommand",
	4:  "DropDatabaseCommand",
	5:  "CreateRetentionPolicyCommand",
	6:  "DropRetentionPolicyCommand",
	7:  "SetDefaultRetentionPolicyCommand",
	8:  "UpdateRetentionPolicyCommand",
	9:  "CreateShardGroupCommand",
	10: "DeleteShardGroupCommand",
	11: "CreateContinuousQueryCommand",
	12: "DropContinuousQueryCommand",
	13: "CreateUserCommand",
	14: "DropUserCommand",
	15: "UpdateUserCommand",
	16: "SetPrivilegeCommand",
	17: "SetDataCommand",
	18: "SetAdminPrivilegeCommand",
	19: "UpdateNodeCommand",
	21: "CreateSubscriptionCommand",
	22: "DropSubscriptionCommand",
	23: "RemovePeerCommand",
	24: "CreateMetaNodeCommand",
	25: "CreateDataNodeCommand",
	26: "UpdateDataNodeCommand",
	27: "DeleteMetaNodeCommand",
	28: "DeleteDataNodeCommand",
	29: "SetMetaNodeCommand",
	30: "DropShardCommand",
}
var Command_Type_value = map[string]int32{
	"CreateNodeCommand":                1,
	"DeleteNodeCommand":                2,
	"CreateDatabaseCommand":            3,
	"DropDatabaseCommand":              4,
	"CreateRetentionPolicyCommand":     5,
	"DropRetentionPolicyCommand":       6,
	"SetDefaultRetentionPolicyCommand": 7,
	"UpdateRetentionPolicyCommand":     8,
	"CreateShardGroupCommand":          9,
	"DeleteShardGroupCommand":          10,
	"CreateContinuousQueryCommand":     11,
	"DropContinuousQueryCommand":       12,
	"CreateUserCommand":                13,
	"DropUserCommand":                  14,
	"UpdateUserCommand":                15,
	"SetPrivilegeCommand":              16,
	"SetDataCommand":                   17,
	"SetAdminPrivilegeCommand":         18,
	"UpdateNodeCommand":                19,
	"CreateSubscriptionCommand":        21,
	"DropSubscriptionCommand":          22,
	"RemovePeerCommand":                23,
	"CreateMetaNodeCommand":            24,
	"CreateDataNodeCommand":            25,
	"UpdateDataNodeCommand":            26,
	"DeleteMetaNodeCommand":            27,
	"DeleteDataNodeCommand":            28,
	"SetMetaNodeCommand":               29,
	"DropShardCommand":                 30,
}

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

type Data struct {
	Term            *uint64         `protobuf:"varint,1,req,name=Term" json:"Term,omitempty"`
	Index           *uint64         `protobuf:"varint,2,req,name=Index" json:"Index,omitempty"`
	ClusterID       *uint64         `protobuf:"varint,3,req,name=ClusterID" json:"ClusterID,omitempty"`
	Nodes           []*NodeInfo     `protobuf:"bytes,4,rep,name=Nodes" json:"Nodes,omitempty"`
	Databases       []*DatabaseInfo `protobuf:"bytes,5,rep,name=Databases" json:"Databases,omitempty"`
	Users           []*UserInfo     `protobuf:"bytes,6,rep,name=Users" json:"Users,omitempty"`
	MaxNodeID       *uint64         `protobuf:"varint,7,req,name=MaxNodeID" json:"MaxNodeID,omitempty"`
	MaxShardGroupID *uint64         `protobuf:"varint,8,req,name=MaxShardGroupID" json:"MaxShardGroupID,omitempty"`
	MaxShardID      *uint64         `protobuf:"varint,9,req,name=MaxShardID" json:"MaxShardID,omitempty"`
	// added for 0.10.0
	DataNodes        []*NodeInfo `protobuf:"bytes,10,rep,name=DataNodes" json:"DataNodes,omitempty"`
	MetaNodes        []*NodeInfo `protobuf:"bytes,11,rep,name=MetaNodes" json:"MetaNodes,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *Data) Reset()         { *m = Data{} }
func (m *Data) String() string { return proto.CompactTextString(m) }
func (*Data) ProtoMessage()    {}

func (m *Data) GetTerm() uint64 {
	if m != nil && m.Term != nil {
		return *m.Term
	}
	return 0
}

func (m *Data) GetIndex() uint64 {
	if m != nil && m.Index != nil {
		return *m.Index
	}
	return 0
}

func (m *Data) GetClusterID() uint64 {
	if m != nil && m.ClusterID != nil {
		return *m.ClusterID
	}
	return 0
}

func (m *Data) GetNodes() []*NodeInfo {
	if m != nil {
		return m.Nodes
	}
	return nil
}

func (m *Data) GetDatabases() []*DatabaseInfo {
	if m != nil {
		return m.Databases
	}
	return nil
}

func (m *Data) GetUsers() []*UserInfo {
	if m != nil {
		return m.Users
	}
	return nil
}

func (m *Data) GetMaxNodeID() uint64 {
	if m != nil && m.MaxNodeID != nil {
		return *m.MaxNodeID
	}
	return 0
}

func (m *Data) GetMaxShardGroupID() uint64 {
	if m != nil && m.MaxShardGroupID != nil {
		return *m.MaxShardGroupID
	}
	return 0
}

func (m *Data) GetMaxShardID() uint64 {
	if m != nil && m.MaxShardID != nil {
		return *m.MaxShardID
	}
	return 0
}

func (m *Data) GetDataNodes() []*NodeInfo {
	if m != nil {
		return m.DataNodes
	}
	return nil
}

func (m *Data) GetMetaNodes() []*NodeInfo {
	if m != nil {
		return m.MetaNodes
	}
	return nil
}

type NodeInfo struct {
	ID               *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"`
	Host             *string `protobuf:"bytes,2,req,name=Host" json:"Host,omitempty"`
	TCPHost          *string `protobuf:"bytes,3,opt,name=TCPHost" json:"TCPHost,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *NodeInfo) Reset()         { *m = NodeInfo{} }
func (m *NodeInfo) String() string { return proto.CompactTextString(m) }
func (*NodeInfo) ProtoMessage()    {}

func (m *NodeInfo) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

func (m *NodeInfo) GetHost() string {
	if m != nil && m.Host != nil {
		return *m.Host
	}
	return ""
}

func (m *NodeInfo) GetTCPHost() string {
	if m != nil && m.TCPHost != nil {
		return *m.TCPHost
	}
	return ""
}

type DatabaseInfo struct {
	Name                   *string                `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	DefaultRetentionPolicy *string                `protobuf:"bytes,2,req,name=DefaultRetentionPolicy" json:"DefaultRetentionPolicy,omitempty"`
	RetentionPolicies      []*RetentionPolicyInfo `protobuf:"bytes,3,rep,name=RetentionPolicies" json:"RetentionPolicies,omitempty"`
	ContinuousQueries      []*ContinuousQueryInfo `protobuf:"bytes,4,rep,name=ContinuousQueries" json:"ContinuousQueries,omitempty"`
	XXX_unrecognized       []byte                 `json:"-"`
}

func (m *DatabaseInfo) Reset()         { *m = DatabaseInfo{} }
func (m *DatabaseInfo) String() string { return proto.CompactTextString(m) }
func (*DatabaseInfo) ProtoMessage()    {}

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

func (m *DatabaseInfo) GetDefaultRetentionPolicy() string {
	if m != nil && m.DefaultRetentionPolicy != nil {
		return *m.DefaultRetentionPolicy
	}
	return ""
}

func (m *DatabaseInfo) GetRetentionPolicies() []*RetentionPolicyInfo {
	if m != nil {
		return m.RetentionPolicies
	}
	return nil
}

func (m *DatabaseInfo) GetContinuousQueries() []*ContinuousQueryInfo {
	if m != nil {
		return m.ContinuousQueries
	}
	return nil
}

type RetentionPolicyInfo struct {
	Name               *string             `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	Duration           *int64              `protobuf:"varint,2,req,name=Duration" json:"Duration,omitempty"`
	ShardGroupDuration *int64              `protobuf:"varint,3,req,name=ShardGroupDuration" json:"ShardGroupDuration,omitempty"`
	ReplicaN           *uint32             `protobuf:"varint,4,req,name=ReplicaN" json:"ReplicaN,omitempty"`
	ShardGroups        []*ShardGroupInfo   `protobuf:"bytes,5,rep,name=ShardGroups" json:"ShardGroups,omitempty"`
	Subscriptions      []*SubscriptionInfo `protobuf:"bytes,6,rep,name=Subscriptions" json:"Subscriptions,omitempty"`
	XXX_unrecognized   []byte              `json:"-"`
}

func (m *RetentionPolicyInfo) Reset()         { *m = RetentionPolicyInfo{} }
func (m *RetentionPolicyInfo) String() string { return proto.CompactTextString(m) }
func (*RetentionPolicyInfo) ProtoMessage()    {}

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

func (m *RetentionPolicyInfo) GetDuration() int64 {
	if m != nil && m.Duration != nil {
		return *m.Duration
	}
	return 0
}

func (m *RetentionPolicyInfo) GetShardGroupDuration() int64 {
	if m != nil && m.ShardGroupDuration != nil {
		return *m.ShardGroupDuration
	}
	return 0
}

func (m *RetentionPolicyInfo) GetReplicaN() uint32 {
	if m != nil && m.ReplicaN != nil {
		return *m.ReplicaN
	}
	return 0
}

func (m *RetentionPolicyInfo) GetShardGroups() []*ShardGroupInfo {
	if m != nil {
		return m.ShardGroups
	}
	return nil
}

func (m *RetentionPolicyInfo) GetSubscriptions() []*SubscriptionInfo {
	if m != nil {
		return m.Subscriptions
	}
	return nil
}

type ShardGroupInfo struct {
	ID               *uint64      `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"`
	StartTime        *int64       `protobuf:"varint,2,req,name=StartTime" json:"StartTime,omitempty"`
	EndTime          *int64       `protobuf:"varint,3,req,name=EndTime" json:"EndTime,omitempty"`
	DeletedAt        *int64       `protobuf:"varint,4,req,name=DeletedAt" json:"DeletedAt,omitempty"`
	Shards           []*ShardInfo `protobuf:"bytes,5,rep,name=Shards" json:"Shards,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

func (m *ShardGroupInfo) Reset()         { *m = ShardGroupInfo{} }
func (m *ShardGroupInfo) String() string { return proto.CompactTextString(m) }
func (*ShardGroupInfo) ProtoMessage()    {}

func (m *ShardGroupInfo) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

func (m *ShardGroupInfo) GetStartTime() int64 {
	if m != nil && m.StartTime != nil {
		return *m.StartTime
	}
	return 0
}

func (m *ShardGroupInfo) GetEndTime() int64 {
	if m != nil && m.EndTime != nil {
		return *m.EndTime
	}
	return 0
}

func (m *ShardGroupInfo) GetDeletedAt() int64 {
	if m != nil && m.DeletedAt != nil {
		return *m.DeletedAt
	}
	return 0
}

func (m *ShardGroupInfo) GetShards() []*ShardInfo {
	if m != nil {
		return m.Shards
	}
	return nil
}

type ShardInfo struct {
	ID               *uint64       `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"`
	OwnerIDs         []uint64      `protobuf:"varint,2,rep,name=OwnerIDs" json:"OwnerIDs,omitempty"`
	Owners           []*ShardOwner `protobuf:"bytes,3,rep,name=Owners" json:"Owners,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

func (m *ShardInfo) Reset()         { *m = ShardInfo{} }
func (m *ShardInfo) String() string { return proto.CompactTextString(m) }
func (*ShardInfo) ProtoMessage()    {}

func (m *ShardInfo) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

func (m *ShardInfo) GetOwnerIDs() []uint64 {
	if m != nil {
		return m.OwnerIDs
	}
	return nil
}

func (m *ShardInfo) GetOwners() []*ShardOwner {
	if m != nil {
		return m.Owners
	}
	return nil
}

type SubscriptionInfo struct {
	Name             *string  `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	Mode             *string  `protobuf:"bytes,2,req,name=Mode" json:"Mode,omitempty"`
	Destinations     []string `protobuf:"bytes,3,rep,name=Destinations" json:"Destinations,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *SubscriptionInfo) Reset()         { *m = SubscriptionInfo{} }
func (m *SubscriptionInfo) String() string { return proto.CompactTextString(m) }
func (*SubscriptionInfo) ProtoMessage()    {}

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

func (m *SubscriptionInfo) GetMode() string {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return ""
}

func (m *SubscriptionInfo) GetDestinations() []string {
	if m != nil {
		return m.Destinations
	}
	return nil
}

type ShardOwner struct {
	NodeID           *uint64 `protobuf:"varint,1,req,name=NodeID" json:"NodeID,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *ShardOwner) Reset()         { *m = ShardOwner{} }
func (m *ShardOwner) String() string { return proto.CompactTextString(m) }
func (*ShardOwner) ProtoMessage()    {}

func (m *ShardOwner) GetNodeID() uint64 {
	if m != nil && m.NodeID != nil {
		return *m.NodeID
	}
	return 0
}

type ContinuousQueryInfo struct {
	Name             *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	Query            *string `protobuf:"bytes,2,req,name=Query" json:"Query,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *ContinuousQueryInfo) Reset()         { *m = ContinuousQueryInfo{} }
func (m *ContinuousQueryInfo) String() string { return proto.CompactTextString(m) }
func (*ContinuousQueryInfo) ProtoMessage()    {}

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

func (m *ContinuousQueryInfo) GetQuery() string {
	if m != nil && m.Query != nil {
		return *m.Query
	}
	return ""
}

type UserInfo struct {
	Name             *string          `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	Hash             *string          `protobuf:"bytes,2,req,name=Hash" json:"Hash,omitempty"`
	Admin            *bool            `protobuf:"varint,3,req,name=Admin" json:"Admin,omitempty"`
	Privileges       []*UserPrivilege `protobuf:"bytes,4,rep,name=Privileges" json:"Privileges,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *UserInfo) Reset()         { *m = UserInfo{} }
func (m *UserInfo) String() string { return proto.CompactTextString(m) }
func (*UserInfo) ProtoMessage()    {}

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

func (m *UserInfo) GetHash() string {
	if m != nil && m.Hash != nil {
		return *m.Hash
	}
	return ""
}

func (m *UserInfo) GetAdmin() bool {
	if m != nil && m.Admin != nil {
		return *m.Admin
	}
	return false
}

func (m *UserInfo) GetPrivileges() []*UserPrivilege {
	if m != nil {
		return m.Privileges
	}
	return nil
}

type UserPrivilege struct {
	Database         *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"`
	Privilege        *int32  `protobuf:"varint,2,req,name=Privilege" json:"Privilege,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *UserPrivilege) Reset()         { *m = UserPrivilege{} }
func (m *UserPrivilege) String() string { return proto.CompactTextString(m) }
func (*UserPrivilege) ProtoMessage()    {}

func (m *UserPrivilege) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

func (m *UserPrivilege) GetPrivilege() int32 {
	if m != nil && m.Privilege != nil {
		return *m.Privilege
	}
	return 0
}

type Command struct {
	Type             *Command_Type             `protobuf:"varint,1,req,name=type,enum=internal.Command_Type" json:"type,omitempty"`
	XXX_extensions   map[int32]proto.Extension `json:"-"`
	XXX_unrecognized []byte                    `json:"-"`
}

func (m *Command) Reset()         { *m = Command{} }
func (m *Command) String() string { return proto.CompactTextString(m) }
func (*Command) ProtoMessage()    {}

var extRange_Command = []proto.ExtensionRange{
	{100, 536870911},
}

func (*Command) ExtensionRangeArray() []proto.ExtensionRange {
	return extRange_Command
}
func (m *Command) ExtensionMap() map[int32]proto.Extension {
	if m.XXX_extensions == nil {
		m.XXX_extensions = make(map[int32]proto.Extension)
	}
	return m.XXX_extensions
}

func (m *Command) GetType() Command_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return Command_CreateNodeCommand
}

// This isn't used in >= 0.10.0. Kept around for upgrade purposes. Instead
// look at CreateDataNodeCommand and CreateMetaNodeCommand
type CreateNodeCommand struct {
	Host             *string `protobuf:"bytes,1,req,name=Host" json:"Host,omitempty"`
	Rand             *uint64 `protobuf:"varint,2,req,name=Rand" json:"Rand,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CreateNodeCommand) Reset()         { *m = CreateNodeCommand{} }
func (m *CreateNodeCommand) String() string { return proto.CompactTextString(m) }
func (*CreateNodeCommand) ProtoMessage()    {}

func (m *CreateNodeCommand) GetHost() string {
	if m != nil && m.Host != nil {
		return *m.Host
	}
	return ""
}

func (m *CreateNodeCommand) GetRand() uint64 {
	if m != nil && m.Rand != nil {
		return *m.Rand
	}
	return 0
}

var E_CreateNodeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*CreateNodeCommand)(nil),
	Field:         101,
	Name:          "internal.CreateNodeCommand.command",
	Tag:           "bytes,101,opt,name=command",
}

type DeleteNodeCommand struct {
	ID               *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"`
	Force            *bool   `protobuf:"varint,2,req,name=Force" json:"Force,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *DeleteNodeCommand) Reset()         { *m = DeleteNodeCommand{} }
func (m *DeleteNodeCommand) String() string { return proto.CompactTextString(m) }
func (*DeleteNodeCommand) ProtoMessage()    {}

func (m *DeleteNodeCommand) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

func (m *DeleteNodeCommand) GetForce() bool {
	if m != nil && m.Force != nil {
		return *m.Force
	}
	return false
}

var E_DeleteNodeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DeleteNodeCommand)(nil),
	Field:         102,
	Name:          "internal.DeleteNodeCommand.command",
	Tag:           "bytes,102,opt,name=command",
}

type CreateDatabaseCommand struct {
	Name             *string              `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	RetentionPolicy  *RetentionPolicyInfo `protobuf:"bytes,2,opt,name=RetentionPolicy" json:"RetentionPolicy,omitempty"`
	XXX_unrecognized []byte               `json:"-"`
}

func (m *CreateDatabaseCommand) Reset()         { *m = CreateDatabaseCommand{} }
func (m *CreateDatabaseCommand) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseCommand) ProtoMessage()    {}

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

func (m *CreateDatabaseCommand) GetRetentionPolicy() *RetentionPolicyInfo {
	if m != nil {
		return m.RetentionPolicy
	}
	return nil
}

var E_CreateDatabaseCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*CreateDatabaseCommand)(nil),
	Field:         103,
	Name:          "internal.CreateDatabaseCommand.command",
	Tag:           "bytes,103,opt,name=command",
}

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

func (m *DropDatabaseCommand) Reset()         { *m = DropDatabaseCommand{} }
func (m *DropDatabaseCommand) String() string { return proto.CompactTextString(m) }
func (*DropDatabaseCommand) ProtoMessage()    {}

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

var E_DropDatabaseCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DropDatabaseCommand)(nil),
	Field:         104,
	Name:          "internal.DropDatabaseCommand.command",
	Tag:           "bytes,104,opt,name=command",
}

type CreateRetentionPolicyCommand struct {
	Database         *string              `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"`
	RetentionPolicy  *RetentionPolicyInfo `protobuf:"bytes,2,req,name=RetentionPolicy" json:"RetentionPolicy,omitempty"`
	XXX_unrecognized []byte               `json:"-"`
}

func (m *CreateRetentionPolicyCommand) Reset()         { *m = CreateRetentionPolicyCommand{} }
func (m *CreateRetentionPolicyCommand) String() string { return proto.CompactTextString(m) }
func (*CreateRetentionPolicyCommand) ProtoMessage()    {}

func (m *CreateRetentionPolicyCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

func (m *CreateRetentionPolicyCommand) GetRetentionPolicy() *RetentionPolicyInfo {
	if m != nil {
		return m.RetentionPolicy
	}
	return nil
}

var E_CreateRetentionPolicyCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*CreateRetentionPolicyCommand)(nil),
	Field:         105,
	Name:          "internal.CreateRetentionPolicyCommand.command",
	Tag:           "bytes,105,opt,name=command",
}

type DropRetentionPolicyCommand struct {
	Database         *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"`
	Name             *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *DropRetentionPolicyCommand) Reset()         { *m = DropRetentionPolicyCommand{} }
func (m *DropRetentionPolicyCommand) String() string { return proto.CompactTextString(m) }
func (*DropRetentionPolicyCommand) ProtoMessage()    {}

func (m *DropRetentionPolicyCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

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

var E_DropRetentionPolicyCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DropRetentionPolicyCommand)(nil),
	Field:         106,
	Name:          "internal.DropRetentionPolicyCommand.command",
	Tag:           "bytes,106,opt,name=command",
}

type SetDefaultRetentionPolicyCommand struct {
	Database         *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"`
	Name             *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *SetDefaultRetentionPolicyCommand) Reset()         { *m = SetDefaultRetentionPolicyCommand{} }
func (m *SetDefaultRetentionPolicyCommand) String() string { return proto.CompactTextString(m) }
func (*SetDefaultRetentionPolicyCommand) ProtoMessage()    {}

func (m *SetDefaultRetentionPolicyCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

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

var E_SetDefaultRetentionPolicyCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*SetDefaultRetentionPolicyCommand)(nil),
	Field:         107,
	Name:          "internal.SetDefaultRetentionPolicyCommand.command",
	Tag:           "bytes,107,opt,name=command",
}

type UpdateRetentionPolicyCommand struct {
	Database         *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"`
	Name             *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"`
	NewName          *string `protobuf:"bytes,3,opt,name=NewName" json:"NewName,omitempty"`
	Duration         *int64  `protobuf:"varint,4,opt,name=Duration" json:"Duration,omitempty"`
	ReplicaN         *uint32 `protobuf:"varint,5,opt,name=ReplicaN" json:"ReplicaN,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *UpdateRetentionPolicyCommand) Reset()         { *m = UpdateRetentionPolicyCommand{} }
func (m *UpdateRetentionPolicyCommand) String() string { return proto.CompactTextString(m) }
func (*UpdateRetentionPolicyCommand) ProtoMessage()    {}

func (m *UpdateRetentionPolicyCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

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

func (m *UpdateRetentionPolicyCommand) GetNewName() string {
	if m != nil && m.NewName != nil {
		return *m.NewName
	}
	return ""
}

func (m *UpdateRetentionPolicyCommand) GetDuration() int64 {
	if m != nil && m.Duration != nil {
		return *m.Duration
	}
	return 0
}

func (m *UpdateRetentionPolicyCommand) GetReplicaN() uint32 {
	if m != nil && m.ReplicaN != nil {
		return *m.ReplicaN
	}
	return 0
}

var E_UpdateRetentionPolicyCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*UpdateRetentionPolicyCommand)(nil),
	Field:         108,
	Name:          "internal.UpdateRetentionPolicyCommand.command",
	Tag:           "bytes,108,opt,name=command",
}

type CreateShardGroupCommand struct {
	Database         *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"`
	Policy           *string `protobuf:"bytes,2,req,name=Policy" json:"Policy,omitempty"`
	Timestamp        *int64  `protobuf:"varint,3,req,name=Timestamp" json:"Timestamp,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CreateShardGroupCommand) Reset()         { *m = CreateShardGroupCommand{} }
func (m *CreateShardGroupCommand) String() string { return proto.CompactTextString(m) }
func (*CreateShardGroupCommand) ProtoMessage()    {}

func (m *CreateShardGroupCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

func (m *CreateShardGroupCommand) GetPolicy() string {
	if m != nil && m.Policy != nil {
		return *m.Policy
	}
	return ""
}

func (m *CreateShardGroupCommand) GetTimestamp() int64 {
	if m != nil && m.Timestamp != nil {
		return *m.Timestamp
	}
	return 0
}

var E_CreateShardGroupCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*CreateShardGroupCommand)(nil),
	Field:         109,
	Name:          "internal.CreateShardGroupCommand.command",
	Tag:           "bytes,109,opt,name=command",
}

type DeleteShardGroupCommand struct {
	Database         *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"`
	Policy           *string `protobuf:"bytes,2,req,name=Policy" json:"Policy,omitempty"`
	ShardGroupID     *uint64 `protobuf:"varint,3,req,name=ShardGroupID" json:"ShardGroupID,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *DeleteShardGroupCommand) Reset()         { *m = DeleteShardGroupCommand{} }
func (m *DeleteShardGroupCommand) String() string { return proto.CompactTextString(m) }
func (*DeleteShardGroupCommand) ProtoMessage()    {}

func (m *DeleteShardGroupCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

func (m *DeleteShardGroupCommand) GetPolicy() string {
	if m != nil && m.Policy != nil {
		return *m.Policy
	}
	return ""
}

func (m *DeleteShardGroupCommand) GetShardGroupID() uint64 {
	if m != nil && m.ShardGroupID != nil {
		return *m.ShardGroupID
	}
	return 0
}

var E_DeleteShardGroupCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DeleteShardGroupCommand)(nil),
	Field:         110,
	Name:          "internal.DeleteShardGroupCommand.command",
	Tag:           "bytes,110,opt,name=command",
}

type CreateContinuousQueryCommand struct {
	Database         *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"`
	Name             *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"`
	Query            *string `protobuf:"bytes,3,req,name=Query" json:"Query,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CreateContinuousQueryCommand) Reset()         { *m = CreateContinuousQueryCommand{} }
func (m *CreateContinuousQueryCommand) String() string { return proto.CompactTextString(m) }
func (*CreateContinuousQueryCommand) ProtoMessage()    {}

func (m *CreateContinuousQueryCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

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

func (m *CreateContinuousQueryCommand) GetQuery() string {
	if m != nil && m.Query != nil {
		return *m.Query
	}
	return ""
}

var E_CreateContinuousQueryCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*CreateContinuousQueryCommand)(nil),
	Field:         111,
	Name:          "internal.CreateContinuousQueryCommand.command",
	Tag:           "bytes,111,opt,name=command",
}

type DropContinuousQueryCommand struct {
	Database         *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"`
	Name             *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *DropContinuousQueryCommand) Reset()         { *m = DropContinuousQueryCommand{} }
func (m *DropContinuousQueryCommand) String() string { return proto.CompactTextString(m) }
func (*DropContinuousQueryCommand) ProtoMessage()    {}

func (m *DropContinuousQueryCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

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

var E_DropContinuousQueryCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DropContinuousQueryCommand)(nil),
	Field:         112,
	Name:          "internal.DropContinuousQueryCommand.command",
	Tag:           "bytes,112,opt,name=command",
}

type CreateUserCommand struct {
	Name             *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	Hash             *string `protobuf:"bytes,2,req,name=Hash" json:"Hash,omitempty"`
	Admin            *bool   `protobuf:"varint,3,req,name=Admin" json:"Admin,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CreateUserCommand) Reset()         { *m = CreateUserCommand{} }
func (m *CreateUserCommand) String() string { return proto.CompactTextString(m) }
func (*CreateUserCommand) ProtoMessage()    {}

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

func (m *CreateUserCommand) GetHash() string {
	if m != nil && m.Hash != nil {
		return *m.Hash
	}
	return ""
}

func (m *CreateUserCommand) GetAdmin() bool {
	if m != nil && m.Admin != nil {
		return *m.Admin
	}
	return false
}

var E_CreateUserCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*CreateUserCommand)(nil),
	Field:         113,
	Name:          "internal.CreateUserCommand.command",
	Tag:           "bytes,113,opt,name=command",
}

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

func (m *DropUserCommand) Reset()         { *m = DropUserCommand{} }
func (m *DropUserCommand) String() string { return proto.CompactTextString(m) }
func (*DropUserCommand) ProtoMessage()    {}

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

var E_DropUserCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DropUserCommand)(nil),
	Field:         114,
	Name:          "internal.DropUserCommand.command",
	Tag:           "bytes,114,opt,name=command",
}

type UpdateUserCommand struct {
	Name             *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	Hash             *string `protobuf:"bytes,2,req,name=Hash" json:"Hash,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *UpdateUserCommand) Reset()         { *m = UpdateUserCommand{} }
func (m *UpdateUserCommand) String() string { return proto.CompactTextString(m) }
func (*UpdateUserCommand) ProtoMessage()    {}

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

func (m *UpdateUserCommand) GetHash() string {
	if m != nil && m.Hash != nil {
		return *m.Hash
	}
	return ""
}

var E_UpdateUserCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*UpdateUserCommand)(nil),
	Field:         115,
	Name:          "internal.UpdateUserCommand.command",
	Tag:           "bytes,115,opt,name=command",
}

type SetPrivilegeCommand struct {
	Username         *string `protobuf:"bytes,1,req,name=Username" json:"Username,omitempty"`
	Database         *string `protobuf:"bytes,2,req,name=Database" json:"Database,omitempty"`
	Privilege        *int32  `protobuf:"varint,3,req,name=Privilege" json:"Privilege,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *SetPrivilegeCommand) Reset()         { *m = SetPrivilegeCommand{} }
func (m *SetPrivilegeCommand) String() string { return proto.CompactTextString(m) }
func (*SetPrivilegeCommand) ProtoMessage()    {}

func (m *SetPrivilegeCommand) GetUsername() string {
	if m != nil && m.Username != nil {
		return *m.Username
	}
	return ""
}

func (m *SetPrivilegeCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

func (m *SetPrivilegeCommand) GetPrivilege() int32 {
	if m != nil && m.Privilege != nil {
		return *m.Privilege
	}
	return 0
}

var E_SetPrivilegeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*SetPrivilegeCommand)(nil),
	Field:         116,
	Name:          "internal.SetPrivilegeCommand.command",
	Tag:           "bytes,116,opt,name=command",
}

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

func (m *SetDataCommand) Reset()         { *m = SetDataCommand{} }
func (m *SetDataCommand) String() string { return proto.CompactTextString(m) }
func (*SetDataCommand) ProtoMessage()    {}

func (m *SetDataCommand) GetData() *Data {
	if m != nil {
		return m.Data
	}
	return nil
}

var E_SetDataCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*SetDataCommand)(nil),
	Field:         117,
	Name:          "internal.SetDataCommand.command",
	Tag:           "bytes,117,opt,name=command",
}

type SetAdminPrivilegeCommand struct {
	Username         *string `protobuf:"bytes,1,req,name=Username" json:"Username,omitempty"`
	Admin            *bool   `protobuf:"varint,2,req,name=Admin" json:"Admin,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *SetAdminPrivilegeCommand) Reset()         { *m = SetAdminPrivilegeCommand{} }
func (m *SetAdminPrivilegeCommand) String() string { return proto.CompactTextString(m) }
func (*SetAdminPrivilegeCommand) ProtoMessage()    {}

func (m *SetAdminPrivilegeCommand) GetUsername() string {
	if m != nil && m.Username != nil {
		return *m.Username
	}
	return ""
}

func (m *SetAdminPrivilegeCommand) GetAdmin() bool {
	if m != nil && m.Admin != nil {
		return *m.Admin
	}
	return false
}

var E_SetAdminPrivilegeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*SetAdminPrivilegeCommand)(nil),
	Field:         118,
	Name:          "internal.SetAdminPrivilegeCommand.command",
	Tag:           "bytes,118,opt,name=command",
}

type UpdateNodeCommand struct {
	ID               *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"`
	Host             *string `protobuf:"bytes,2,req,name=Host" json:"Host,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *UpdateNodeCommand) Reset()         { *m = UpdateNodeCommand{} }
func (m *UpdateNodeCommand) String() string { return proto.CompactTextString(m) }
func (*UpdateNodeCommand) ProtoMessage()    {}

func (m *UpdateNodeCommand) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

func (m *UpdateNodeCommand) GetHost() string {
	if m != nil && m.Host != nil {
		return *m.Host
	}
	return ""
}

var E_UpdateNodeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*UpdateNodeCommand)(nil),
	Field:         119,
	Name:          "internal.UpdateNodeCommand.command",
	Tag:           "bytes,119,opt,name=command",
}

type CreateSubscriptionCommand struct {
	Name             *string  `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	Database         *string  `protobuf:"bytes,2,req,name=Database" json:"Database,omitempty"`
	RetentionPolicy  *string  `protobuf:"bytes,3,req,name=RetentionPolicy" json:"RetentionPolicy,omitempty"`
	Mode             *string  `protobuf:"bytes,4,req,name=Mode" json:"Mode,omitempty"`
	Destinations     []string `protobuf:"bytes,5,rep,name=Destinations" json:"Destinations,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *CreateSubscriptionCommand) Reset()         { *m = CreateSubscriptionCommand{} }
func (m *CreateSubscriptionCommand) String() string { return proto.CompactTextString(m) }
func (*CreateSubscriptionCommand) ProtoMessage()    {}

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

func (m *CreateSubscriptionCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

func (m *CreateSubscriptionCommand) GetRetentionPolicy() string {
	if m != nil && m.RetentionPolicy != nil {
		return *m.RetentionPolicy
	}
	return ""
}

func (m *CreateSubscriptionCommand) GetMode() string {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return ""
}

func (m *CreateSubscriptionCommand) GetDestinations() []string {
	if m != nil {
		return m.Destinations
	}
	return nil
}

var E_CreateSubscriptionCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*CreateSubscriptionCommand)(nil),
	Field:         121,
	Name:          "internal.CreateSubscriptionCommand.command",
	Tag:           "bytes,121,opt,name=command",
}

type DropSubscriptionCommand struct {
	Name             *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"`
	Database         *string `protobuf:"bytes,2,req,name=Database" json:"Database,omitempty"`
	RetentionPolicy  *string `protobuf:"bytes,3,req,name=RetentionPolicy" json:"RetentionPolicy,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *DropSubscriptionCommand) Reset()         { *m = DropSubscriptionCommand{} }
func (m *DropSubscriptionCommand) String() string { return proto.CompactTextString(m) }
func (*DropSubscriptionCommand) ProtoMessage()    {}

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

func (m *DropSubscriptionCommand) GetDatabase() string {
	if m != nil && m.Database != nil {
		return *m.Database
	}
	return ""
}

func (m *DropSubscriptionCommand) GetRetentionPolicy() string {
	if m != nil && m.RetentionPolicy != nil {
		return *m.RetentionPolicy
	}
	return ""
}

var E_DropSubscriptionCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DropSubscriptionCommand)(nil),
	Field:         122,
	Name:          "internal.DropSubscriptionCommand.command",
	Tag:           "bytes,122,opt,name=command",
}

type RemovePeerCommand struct {
	ID               *uint64 `protobuf:"varint,1,opt,name=ID" json:"ID,omitempty"`
	Addr             *string `protobuf:"bytes,2,req,name=Addr" json:"Addr,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *RemovePeerCommand) Reset()         { *m = RemovePeerCommand{} }
func (m *RemovePeerCommand) String() string { return proto.CompactTextString(m) }
func (*RemovePeerCommand) ProtoMessage()    {}

func (m *RemovePeerCommand) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

func (m *RemovePeerCommand) GetAddr() string {
	if m != nil && m.Addr != nil {
		return *m.Addr
	}
	return ""
}

var E_RemovePeerCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*RemovePeerCommand)(nil),
	Field:         123,
	Name:          "internal.RemovePeerCommand.command",
	Tag:           "bytes,123,opt,name=command",
}

type CreateMetaNodeCommand struct {
	HTTPAddr         *string `protobuf:"bytes,1,req,name=HTTPAddr" json:"HTTPAddr,omitempty"`
	TCPAddr          *string `protobuf:"bytes,2,req,name=TCPAddr" json:"TCPAddr,omitempty"`
	Rand             *uint64 `protobuf:"varint,3,req,name=Rand" json:"Rand,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CreateMetaNodeCommand) Reset()         { *m = CreateMetaNodeCommand{} }
func (m *CreateMetaNodeCommand) String() string { return proto.CompactTextString(m) }
func (*CreateMetaNodeCommand) ProtoMessage()    {}

func (m *CreateMetaNodeCommand) GetHTTPAddr() string {
	if m != nil && m.HTTPAddr != nil {
		return *m.HTTPAddr
	}
	return ""
}

func (m *CreateMetaNodeCommand) GetTCPAddr() string {
	if m != nil && m.TCPAddr != nil {
		return *m.TCPAddr
	}
	return ""
}

func (m *CreateMetaNodeCommand) GetRand() uint64 {
	if m != nil && m.Rand != nil {
		return *m.Rand
	}
	return 0
}

var E_CreateMetaNodeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*CreateMetaNodeCommand)(nil),
	Field:         124,
	Name:          "internal.CreateMetaNodeCommand.command",
	Tag:           "bytes,124,opt,name=command",
}

type CreateDataNodeCommand struct {
	HTTPAddr         *string `protobuf:"bytes,1,req,name=HTTPAddr" json:"HTTPAddr,omitempty"`
	TCPAddr          *string `protobuf:"bytes,2,req,name=TCPAddr" json:"TCPAddr,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CreateDataNodeCommand) Reset()         { *m = CreateDataNodeCommand{} }
func (m *CreateDataNodeCommand) String() string { return proto.CompactTextString(m) }
func (*CreateDataNodeCommand) ProtoMessage()    {}

func (m *CreateDataNodeCommand) GetHTTPAddr() string {
	if m != nil && m.HTTPAddr != nil {
		return *m.HTTPAddr
	}
	return ""
}

func (m *CreateDataNodeCommand) GetTCPAddr() string {
	if m != nil && m.TCPAddr != nil {
		return *m.TCPAddr
	}
	return ""
}

var E_CreateDataNodeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*CreateDataNodeCommand)(nil),
	Field:         125,
	Name:          "internal.CreateDataNodeCommand.command",
	Tag:           "bytes,125,opt,name=command",
}

type UpdateDataNodeCommand struct {
	ID               *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"`
	Host             *string `protobuf:"bytes,2,req,name=Host" json:"Host,omitempty"`
	TCPHost          *string `protobuf:"bytes,3,req,name=TCPHost" json:"TCPHost,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *UpdateDataNodeCommand) Reset()         { *m = UpdateDataNodeCommand{} }
func (m *UpdateDataNodeCommand) String() string { return proto.CompactTextString(m) }
func (*UpdateDataNodeCommand) ProtoMessage()    {}

func (m *UpdateDataNodeCommand) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

func (m *UpdateDataNodeCommand) GetHost() string {
	if m != nil && m.Host != nil {
		return *m.Host
	}
	return ""
}

func (m *UpdateDataNodeCommand) GetTCPHost() string {
	if m != nil && m.TCPHost != nil {
		return *m.TCPHost
	}
	return ""
}

var E_UpdateDataNodeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*UpdateDataNodeCommand)(nil),
	Field:         126,
	Name:          "internal.UpdateDataNodeCommand.command",
	Tag:           "bytes,126,opt,name=command",
}

type DeleteMetaNodeCommand struct {
	ID               *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *DeleteMetaNodeCommand) Reset()         { *m = DeleteMetaNodeCommand{} }
func (m *DeleteMetaNodeCommand) String() string { return proto.CompactTextString(m) }
func (*DeleteMetaNodeCommand) ProtoMessage()    {}

func (m *DeleteMetaNodeCommand) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

var E_DeleteMetaNodeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DeleteMetaNodeCommand)(nil),
	Field:         127,
	Name:          "internal.DeleteMetaNodeCommand.command",
	Tag:           "bytes,127,opt,name=command",
}

type DeleteDataNodeCommand struct {
	ID               *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *DeleteDataNodeCommand) Reset()         { *m = DeleteDataNodeCommand{} }
func (m *DeleteDataNodeCommand) String() string { return proto.CompactTextString(m) }
func (*DeleteDataNodeCommand) ProtoMessage()    {}

func (m *DeleteDataNodeCommand) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

var E_DeleteDataNodeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DeleteDataNodeCommand)(nil),
	Field:         128,
	Name:          "internal.DeleteDataNodeCommand.command",
	Tag:           "bytes,128,opt,name=command",
}

type Response struct {
	OK               *bool   `protobuf:"varint,1,req,name=OK" json:"OK,omitempty"`
	Error            *string `protobuf:"bytes,2,opt,name=Error" json:"Error,omitempty"`
	Index            *uint64 `protobuf:"varint,3,opt,name=Index" json:"Index,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *Response) Reset()         { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage()    {}

func (m *Response) GetOK() bool {
	if m != nil && m.OK != nil {
		return *m.OK
	}
	return false
}

func (m *Response) GetError() string {
	if m != nil && m.Error != nil {
		return *m.Error
	}
	return ""
}

func (m *Response) GetIndex() uint64 {
	if m != nil && m.Index != nil {
		return *m.Index
	}
	return 0
}

// SetMetaNodeCommand is for the initial metanode in a cluster or
// if the single host restarts and its hostname changes, this will update it
type SetMetaNodeCommand struct {
	HTTPAddr         *string `protobuf:"bytes,1,req,name=HTTPAddr" json:"HTTPAddr,omitempty"`
	TCPAddr          *string `protobuf:"bytes,2,req,name=TCPAddr" json:"TCPAddr,omitempty"`
	Rand             *uint64 `protobuf:"varint,3,req,name=Rand" json:"Rand,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *SetMetaNodeCommand) Reset()         { *m = SetMetaNodeCommand{} }
func (m *SetMetaNodeCommand) String() string { return proto.CompactTextString(m) }
func (*SetMetaNodeCommand) ProtoMessage()    {}

func (m *SetMetaNodeCommand) GetHTTPAddr() string {
	if m != nil && m.HTTPAddr != nil {
		return *m.HTTPAddr
	}
	return ""
}

func (m *SetMetaNodeCommand) GetTCPAddr() string {
	if m != nil && m.TCPAddr != nil {
		return *m.TCPAddr
	}
	return ""
}

func (m *SetMetaNodeCommand) GetRand() uint64 {
	if m != nil && m.Rand != nil {
		return *m.Rand
	}
	return 0
}

var E_SetMetaNodeCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*SetMetaNodeCommand)(nil),
	Field:         129,
	Name:          "internal.SetMetaNodeCommand.command",
	Tag:           "bytes,129,opt,name=command",
}

type DropShardCommand struct {
	ID               *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *DropShardCommand) Reset()         { *m = DropShardCommand{} }
func (m *DropShardCommand) String() string { return proto.CompactTextString(m) }
func (*DropShardCommand) ProtoMessage()    {}

func (m *DropShardCommand) GetID() uint64 {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return 0
}

var E_DropShardCommand_Command = &proto.ExtensionDesc{
	ExtendedType:  (*Command)(nil),
	ExtensionType: (*DropShardCommand)(nil),
	Field:         130,
	Name:          "internal.DropShardCommand.command",
	Tag:           "bytes,130,opt,name=command",
}

func init() {
	proto.RegisterType((*Data)(nil), "internal.Data")
	proto.RegisterType((*NodeInfo)(nil), "internal.NodeInfo")
	proto.RegisterType((*DatabaseInfo)(nil), "internal.DatabaseInfo")
	proto.RegisterType((*RetentionPolicyInfo)(nil), "internal.RetentionPolicyInfo")
	proto.RegisterType((*ShardGroupInfo)(nil), "internal.ShardGroupInfo")
	proto.RegisterType((*ShardInfo)(nil), "internal.ShardInfo")
	proto.RegisterType((*SubscriptionInfo)(nil), "internal.SubscriptionInfo")
	proto.RegisterType((*ShardOwner)(nil), "internal.ShardOwner")
	proto.RegisterType((*ContinuousQueryInfo)(nil), "internal.ContinuousQueryInfo")
	proto.RegisterType((*UserInfo)(nil), "internal.UserInfo")
	proto.RegisterType((*UserPrivilege)(nil), "internal.UserPrivilege")
	proto.RegisterType((*Command)(nil), "internal.Command")
	proto.RegisterType((*CreateNodeCommand)(nil), "internal.CreateNodeCommand")
	proto.RegisterType((*DeleteNodeCommand)(nil), "internal.DeleteNodeCommand")
	proto.RegisterType((*CreateDatabaseCommand)(nil), "internal.CreateDatabaseCommand")
	proto.RegisterType((*DropDatabaseCommand)(nil), "internal.DropDatabaseCommand")
	proto.RegisterType((*CreateRetentionPolicyCommand)(nil), "internal.CreateRetentionPolicyCommand")
	proto.RegisterType((*DropRetentionPolicyCommand)(nil), "internal.DropRetentionPolicyCommand")
	proto.RegisterType((*SetDefaultRetentionPolicyCommand)(nil), "internal.SetDefaultRetentionPolicyCommand")
	proto.RegisterType((*UpdateRetentionPolicyCommand)(nil), "internal.UpdateRetentionPolicyCommand")
	proto.RegisterType((*CreateShardGroupCommand)(nil), "internal.CreateShardGroupCommand")
	proto.RegisterType((*DeleteShardGroupCommand)(nil), "internal.DeleteShardGroupCommand")
	proto.RegisterType((*CreateContinuousQueryCommand)(nil), "internal.CreateContinuousQueryCommand")
	proto.RegisterType((*DropContinuousQueryCommand)(nil), "internal.DropContinuousQueryCommand")
	proto.RegisterType((*CreateUserCommand)(nil), "internal.CreateUserCommand")
	proto.RegisterType((*DropUserCommand)(nil), "internal.DropUserCommand")
	proto.RegisterType((*UpdateUserCommand)(nil), "internal.UpdateUserCommand")
	proto.RegisterType((*SetPrivilegeCommand)(nil), "internal.SetPrivilegeCommand")
	proto.RegisterType((*SetDataCommand)(nil), "internal.SetDataCommand")
	proto.RegisterType((*SetAdminPrivilegeCommand)(nil), "internal.SetAdminPrivilegeCommand")
	proto.RegisterType((*UpdateNodeCommand)(nil), "internal.UpdateNodeCommand")
	proto.RegisterType((*CreateSubscriptionCommand)(nil), "internal.CreateSubscriptionCommand")
	proto.RegisterType((*DropSubscriptionCommand)(nil), "internal.DropSubscriptionCommand")
	proto.RegisterType((*RemovePeerCommand)(nil), "internal.RemovePeerCommand")
	proto.RegisterType((*CreateMetaNodeCommand)(nil), "internal.CreateMetaNodeCommand")
	proto.RegisterType((*CreateDataNodeCommand)(nil), "internal.CreateDataNodeCommand")
	proto.RegisterType((*UpdateDataNodeCommand)(nil), "internal.UpdateDataNodeCommand")
	proto.RegisterType((*DeleteMetaNodeCommand)(nil), "internal.DeleteMetaNodeCommand")
	proto.RegisterType((*DeleteDataNodeCommand)(nil), "internal.DeleteDataNodeCommand")
	proto.RegisterType((*Response)(nil), "internal.Response")
	proto.RegisterType((*SetMetaNodeCommand)(nil), "internal.SetMetaNodeCommand")
	proto.RegisterType((*DropShardCommand)(nil), "internal.DropShardCommand")
	proto.RegisterEnum("internal.Command_Type", Command_Type_name, Command_Type_value)
	proto.RegisterExtension(E_CreateNodeCommand_Command)
	proto.RegisterExtension(E_DeleteNodeCommand_Command)
	proto.RegisterExtension(E_CreateDatabaseCommand_Command)
	proto.RegisterExtension(E_DropDatabaseCommand_Command)
	proto.RegisterExtension(E_CreateRetentionPolicyCommand_Command)
	proto.RegisterExtension(E_DropRetentionPolicyCommand_Command)
	proto.RegisterExtension(E_SetDefaultRetentionPolicyCommand_Command)
	proto.RegisterExtension(E_UpdateRetentionPolicyCommand_Command)
	proto.RegisterExtension(E_CreateShardGroupCommand_Command)
	proto.RegisterExtension(E_DeleteShardGroupCommand_Command)
	proto.RegisterExtension(E_CreateContinuousQueryCommand_Command)
	proto.RegisterExtension(E_DropContinuousQueryCommand_Command)
	proto.RegisterExtension(E_CreateUserCommand_Command)
	proto.RegisterExtension(E_DropUserCommand_Command)
	proto.RegisterExtension(E_UpdateUserCommand_Command)
	proto.RegisterExtension(E_SetPrivilegeCommand_Command)
	proto.RegisterExtension(E_SetDataCommand_Command)
	proto.RegisterExtension(E_SetAdminPrivilegeCommand_Command)
	proto.RegisterExtension(E_UpdateNodeCommand_Command)
	proto.RegisterExtension(E_CreateSubscriptionCommand_Command)
	proto.RegisterExtension(E_DropSubscriptionCommand_Command)
	proto.RegisterExtension(E_RemovePeerCommand_Command)
	proto.RegisterExtension(E_CreateMetaNodeCommand_Command)
	proto.RegisterExtension(E_CreateDataNodeCommand_Command)
	proto.RegisterExtension(E_UpdateDataNodeCommand_Command)
	proto.RegisterExtension(E_DeleteMetaNodeCommand_Command)
	proto.RegisterExtension(E_DeleteDataNodeCommand_Command)
	proto.RegisterExtension(E_SetMetaNodeCommand_Command)
	proto.RegisterExtension(E_DropShardCommand_Command)
}