service.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: atomix/storage/protocol/rsm/service.proto

package rsm

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/gogo/protobuf/types"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

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

type SessionCommandState int32

const (
	SessionCommandState_COMMAND_OPEN     SessionCommandState = 0
	SessionCommandState_COMMAND_COMPLETE SessionCommandState = 1
)

var SessionCommandState_name = map[int32]string{
	0: "COMMAND_OPEN",
	1: "COMMAND_COMPLETE",
}

var SessionCommandState_value = map[string]int32{
	"COMMAND_OPEN":     0,
	"COMMAND_COMPLETE": 1,
}

func (x SessionCommandState) String() string {
	return proto.EnumName(SessionCommandState_name, int32(x))
}

func (SessionCommandState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e3f642df445f73e7, []int{0}
}

type ResponseCode int32

const (
	ResponseCode_OK             ResponseCode = 0
	ResponseCode_ERROR          ResponseCode = 1
	ResponseCode_UNKNOWN        ResponseCode = 2
	ResponseCode_CANCELED       ResponseCode = 3
	ResponseCode_NOT_FOUND      ResponseCode = 4
	ResponseCode_ALREADY_EXISTS ResponseCode = 5
	ResponseCode_UNAUTHORIZED   ResponseCode = 6
	ResponseCode_FORBIDDEN      ResponseCode = 7
	ResponseCode_CONFLICT       ResponseCode = 8
	ResponseCode_INVALID        ResponseCode = 9
	ResponseCode_UNAVAILABLE    ResponseCode = 10
	ResponseCode_NOT_SUPPORTED  ResponseCode = 11
	ResponseCode_TIMEOUT        ResponseCode = 12
	ResponseCode_INTERNAL       ResponseCode = 13
)

var ResponseCode_name = map[int32]string{
	0:  "OK",
	1:  "ERROR",
	2:  "UNKNOWN",
	3:  "CANCELED",
	4:  "NOT_FOUND",
	5:  "ALREADY_EXISTS",
	6:  "UNAUTHORIZED",
	7:  "FORBIDDEN",
	8:  "CONFLICT",
	9:  "INVALID",
	10: "UNAVAILABLE",
	11: "NOT_SUPPORTED",
	12: "TIMEOUT",
	13: "INTERNAL",
}

var ResponseCode_value = map[string]int32{
	"OK":             0,
	"ERROR":          1,
	"UNKNOWN":        2,
	"CANCELED":       3,
	"NOT_FOUND":      4,
	"ALREADY_EXISTS": 5,
	"UNAUTHORIZED":   6,
	"FORBIDDEN":      7,
	"CONFLICT":       8,
	"INVALID":        9,
	"UNAVAILABLE":    10,
	"NOT_SUPPORTED":  11,
	"TIMEOUT":        12,
	"INTERNAL":       13,
}

func (x ResponseCode) String() string {
	return proto.EnumName(ResponseCode_name, int32(x))
}

func (ResponseCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e3f642df445f73e7, []int{1}
}

type StateMachineSnapshot struct {
	Index     Index              `protobuf:"varint,1,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	Timestamp time.Time          `protobuf:"bytes,2,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
	Sessions  []*SessionSnapshot `protobuf:"bytes,3,rep,name=sessions,proto3" json:"sessions,omitempty"`
	Services  []*ServiceSnapshot `protobuf:"bytes,4,rep,name=services,proto3" json:"services,omitempty"`
}

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

var xxx_messageInfo_StateMachineSnapshot proto.InternalMessageInfo

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

func (m *StateMachineSnapshot) GetTimestamp() time.Time {
	if m != nil {
		return m.Timestamp
	}
	return time.Time{}
}

func (m *StateMachineSnapshot) GetSessions() []*SessionSnapshot {
	if m != nil {
		return m.Sessions
	}
	return nil
}

func (m *StateMachineSnapshot) GetServices() []*ServiceSnapshot {
	if m != nil {
		return m.Services
	}
	return nil
}

type SessionSnapshot struct {
	SessionID   SessionID     `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3,casttype=SessionID" json:"session_id,omitempty"`
	Timeout     time.Duration `protobuf:"bytes,2,opt,name=timeout,proto3,stdduration" json:"timeout"`
	LastUpdated time.Time     `protobuf:"bytes,3,opt,name=last_updated,json=lastUpdated,proto3,stdtime" json:"last_updated"`
}

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

var xxx_messageInfo_SessionSnapshot proto.InternalMessageInfo

func (m *SessionSnapshot) GetSessionID() SessionID {
	if m != nil {
		return m.SessionID
	}
	return 0
}

func (m *SessionSnapshot) GetTimeout() time.Duration {
	if m != nil {
		return m.Timeout
	}
	return 0
}

func (m *SessionSnapshot) GetLastUpdated() time.Time {
	if m != nil {
		return m.LastUpdated
	}
	return time.Time{}
}

type SessionCommandSnapshot struct {
	CommandID        CommandID                `protobuf:"varint,1,opt,name=command_id,json=commandId,proto3,casttype=CommandID" json:"command_id,omitempty"`
	State            SessionCommandState      `protobuf:"varint,2,opt,name=state,proto3,enum=atomix.service.SessionCommandState" json:"state,omitempty"`
	Request          *ServiceCommandRequest   `protobuf:"bytes,3,opt,name=request,proto3" json:"request,omitempty"`
	PendingResponses []ServiceCommandResponse `protobuf:"bytes,4,rep,name=pending_responses,json=pendingResponses,proto3" json:"pending_responses"`
}

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

var xxx_messageInfo_SessionCommandSnapshot proto.InternalMessageInfo

func (m *SessionCommandSnapshot) GetCommandID() CommandID {
	if m != nil {
		return m.CommandID
	}
	return 0
}

func (m *SessionCommandSnapshot) GetState() SessionCommandState {
	if m != nil {
		return m.State
	}
	return SessionCommandState_COMMAND_OPEN
}

func (m *SessionCommandSnapshot) GetRequest() *ServiceCommandRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *SessionCommandSnapshot) GetPendingResponses() []ServiceCommandResponse {
	if m != nil {
		return m.PendingResponses
	}
	return nil
}

type ServiceSnapshot struct {
	ServiceID   ServiceID `protobuf:"varint,1,opt,name=service_id,json=serviceId,proto3,casttype=ServiceID" json:"service_id,omitempty"`
	ServiceInfo `protobuf:"bytes,2,opt,name=service_info,json=serviceInfo,proto3,embedded=service_info" json:"service_info"`
	Data        []byte                    `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	Sessions    []*ServiceSessionSnapshot `protobuf:"bytes,4,rep,name=sessions,proto3" json:"sessions,omitempty"`
}

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

var xxx_messageInfo_ServiceSnapshot proto.InternalMessageInfo

func (m *ServiceSnapshot) GetServiceID() ServiceID {
	if m != nil {
		return m.ServiceID
	}
	return 0
}

func (m *ServiceSnapshot) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ServiceSnapshot) GetSessions() []*ServiceSessionSnapshot {
	if m != nil {
		return m.Sessions
	}
	return nil
}

type ServiceSessionSnapshot struct {
	SessionID SessionID                 `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3,casttype=SessionID" json:"session_id,omitempty"`
	Commands  []*SessionCommandSnapshot `protobuf:"bytes,2,rep,name=commands,proto3" json:"commands,omitempty"`
}

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

var xxx_messageInfo_ServiceSessionSnapshot proto.InternalMessageInfo

func (m *ServiceSessionSnapshot) GetSessionID() SessionID {
	if m != nil {
		return m.SessionID
	}
	return 0
}

func (m *ServiceSessionSnapshot) GetCommands() []*SessionCommandSnapshot {
	if m != nil {
		return m.Commands
	}
	return nil
}

type ServiceInfo struct {
	Type      ServiceType `protobuf:"bytes,1,opt,name=type,proto3,casttype=ServiceType" json:"type,omitempty"`
	Namespace string      `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Name      string      `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}

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

var xxx_messageInfo_ServiceInfo proto.InternalMessageInfo

func (m *ServiceInfo) GetType() ServiceType {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *ServiceInfo) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

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

type PartitionConfigRequest struct {
	PartitionID PartitionID `protobuf:"varint,1,opt,name=partition_id,json=partitionId,proto3,casttype=PartitionID" json:"partition_id,omitempty"`
}

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

var xxx_messageInfo_PartitionConfigRequest proto.InternalMessageInfo

func (m *PartitionConfigRequest) GetPartitionID() PartitionID {
	if m != nil {
		return m.PartitionID
	}
	return 0
}

type PartitionConfigResponse struct {
	Leader    string   `protobuf:"bytes,1,opt,name=leader,proto3" json:"leader,omitempty"`
	Followers []string `protobuf:"bytes,2,rep,name=followers,proto3" json:"followers,omitempty"`
}

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

var xxx_messageInfo_PartitionConfigResponse proto.InternalMessageInfo

func (m *PartitionConfigResponse) GetLeader() string {
	if m != nil {
		return m.Leader
	}
	return ""
}

func (m *PartitionConfigResponse) GetFollowers() []string {
	if m != nil {
		return m.Followers
	}
	return nil
}

type PartitionCommandRequest struct {
	PartitionID PartitionID    `protobuf:"varint,1,opt,name=partition_id,json=partitionId,proto3,casttype=PartitionID" json:"partition_id,omitempty"`
	Request     CommandRequest `protobuf:"bytes,2,opt,name=request,proto3" json:"request"`
}

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

var xxx_messageInfo_PartitionCommandRequest proto.InternalMessageInfo

func (m *PartitionCommandRequest) GetPartitionID() PartitionID {
	if m != nil {
		return m.PartitionID
	}
	return 0
}

func (m *PartitionCommandRequest) GetRequest() CommandRequest {
	if m != nil {
		return m.Request
	}
	return CommandRequest{}
}

type PartitionCommandResponse struct {
	Response CommandResponse `protobuf:"bytes,1,opt,name=response,proto3" json:"response"`
}

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

var xxx_messageInfo_PartitionCommandResponse proto.InternalMessageInfo

func (m *PartitionCommandResponse) GetResponse() CommandResponse {
	if m != nil {
		return m.Response
	}
	return CommandResponse{}
}

type CommandRequest struct {
	Timestamp *time.Time `protobuf:"bytes,1,opt,name=timestamp,proto3,stdtime" json:"timestamp,omitempty"`
	// Types that are valid to be assigned to Request:
	//	*CommandRequest_OpenSession
	//	*CommandRequest_KeepAlive
	//	*CommandRequest_CloseSession
	//	*CommandRequest_SessionCommand
	Request isCommandRequest_Request `protobuf_oneof:"request"`
}

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

var xxx_messageInfo_CommandRequest proto.InternalMessageInfo

type isCommandRequest_Request interface {
	isCommandRequest_Request()
	MarshalTo([]byte) (int, error)
	Size() int
}

type CommandRequest_OpenSession struct {
	OpenSession *OpenSessionRequest `protobuf:"bytes,2,opt,name=open_session,json=openSession,proto3,oneof" json:"open_session,omitempty"`
}
type CommandRequest_KeepAlive struct {
	KeepAlive *KeepAliveRequest `protobuf:"bytes,3,opt,name=keep_alive,json=keepAlive,proto3,oneof" json:"keep_alive,omitempty"`
}
type CommandRequest_CloseSession struct {
	CloseSession *CloseSessionRequest `protobuf:"bytes,4,opt,name=close_session,json=closeSession,proto3,oneof" json:"close_session,omitempty"`
}
type CommandRequest_SessionCommand struct {
	SessionCommand *SessionCommandRequest `protobuf:"bytes,5,opt,name=session_command,json=sessionCommand,proto3,oneof" json:"session_command,omitempty"`
}

func (*CommandRequest_OpenSession) isCommandRequest_Request()    {}
func (*CommandRequest_KeepAlive) isCommandRequest_Request()      {}
func (*CommandRequest_CloseSession) isCommandRequest_Request()   {}
func (*CommandRequest_SessionCommand) isCommandRequest_Request() {}

func (m *CommandRequest) GetRequest() isCommandRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *CommandRequest) GetTimestamp() *time.Time {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *CommandRequest) GetOpenSession() *OpenSessionRequest {
	if x, ok := m.GetRequest().(*CommandRequest_OpenSession); ok {
		return x.OpenSession
	}
	return nil
}

func (m *CommandRequest) GetKeepAlive() *KeepAliveRequest {
	if x, ok := m.GetRequest().(*CommandRequest_KeepAlive); ok {
		return x.KeepAlive
	}
	return nil
}

func (m *CommandRequest) GetCloseSession() *CloseSessionRequest {
	if x, ok := m.GetRequest().(*CommandRequest_CloseSession); ok {
		return x.CloseSession
	}
	return nil
}

func (m *CommandRequest) GetSessionCommand() *SessionCommandRequest {
	if x, ok := m.GetRequest().(*CommandRequest_SessionCommand); ok {
		return x.SessionCommand
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CommandRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CommandRequest_OpenSession)(nil),
		(*CommandRequest_KeepAlive)(nil),
		(*CommandRequest_CloseSession)(nil),
		(*CommandRequest_SessionCommand)(nil),
	}
}

type CommandResponse struct {
	Index Index `protobuf:"varint,1,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	// Types that are valid to be assigned to Response:
	//	*CommandResponse_OpenSession
	//	*CommandResponse_KeepAlive
	//	*CommandResponse_CloseSession
	//	*CommandResponse_SessionCommand
	Response isCommandResponse_Response `protobuf_oneof:"response"`
}

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

var xxx_messageInfo_CommandResponse proto.InternalMessageInfo

type isCommandResponse_Response interface {
	isCommandResponse_Response()
	MarshalTo([]byte) (int, error)
	Size() int
}

type CommandResponse_OpenSession struct {
	OpenSession *OpenSessionResponse `protobuf:"bytes,2,opt,name=open_session,json=openSession,proto3,oneof" json:"open_session,omitempty"`
}
type CommandResponse_KeepAlive struct {
	KeepAlive *KeepAliveResponse `protobuf:"bytes,3,opt,name=keep_alive,json=keepAlive,proto3,oneof" json:"keep_alive,omitempty"`
}
type CommandResponse_CloseSession struct {
	CloseSession *CloseSessionResponse `protobuf:"bytes,4,opt,name=close_session,json=closeSession,proto3,oneof" json:"close_session,omitempty"`
}
type CommandResponse_SessionCommand struct {
	SessionCommand *SessionCommandResponse `protobuf:"bytes,5,opt,name=session_command,json=sessionCommand,proto3,oneof" json:"session_command,omitempty"`
}

func (*CommandResponse_OpenSession) isCommandResponse_Response()    {}
func (*CommandResponse_KeepAlive) isCommandResponse_Response()      {}
func (*CommandResponse_CloseSession) isCommandResponse_Response()   {}
func (*CommandResponse_SessionCommand) isCommandResponse_Response() {}

func (m *CommandResponse) GetResponse() isCommandResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

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

func (m *CommandResponse) GetOpenSession() *OpenSessionResponse {
	if x, ok := m.GetResponse().(*CommandResponse_OpenSession); ok {
		return x.OpenSession
	}
	return nil
}

func (m *CommandResponse) GetKeepAlive() *KeepAliveResponse {
	if x, ok := m.GetResponse().(*CommandResponse_KeepAlive); ok {
		return x.KeepAlive
	}
	return nil
}

func (m *CommandResponse) GetCloseSession() *CloseSessionResponse {
	if x, ok := m.GetResponse().(*CommandResponse_CloseSession); ok {
		return x.CloseSession
	}
	return nil
}

func (m *CommandResponse) GetSessionCommand() *SessionCommandResponse {
	if x, ok := m.GetResponse().(*CommandResponse_SessionCommand); ok {
		return x.SessionCommand
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CommandResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CommandResponse_OpenSession)(nil),
		(*CommandResponse_KeepAlive)(nil),
		(*CommandResponse_CloseSession)(nil),
		(*CommandResponse_SessionCommand)(nil),
	}
}

type OpenSessionRequest struct {
	Timeout time.Duration `protobuf:"bytes,1,opt,name=timeout,proto3,stdduration" json:"timeout"`
}

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

var xxx_messageInfo_OpenSessionRequest proto.InternalMessageInfo

func (m *OpenSessionRequest) GetTimeout() time.Duration {
	if m != nil {
		return m.Timeout
	}
	return 0
}

type OpenSessionResponse struct {
	SessionID SessionID `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3,casttype=SessionID" json:"session_id,omitempty"`
}

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

var xxx_messageInfo_OpenSessionResponse proto.InternalMessageInfo

func (m *OpenSessionResponse) GetSessionID() SessionID {
	if m != nil {
		return m.SessionID
	}
	return 0
}

type KeepAliveRequest struct {
	SessionID     SessionID `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3,casttype=SessionID" json:"session_id,omitempty"`
	LastRequestID RequestID `protobuf:"varint,2,opt,name=last_request_id,json=lastRequestId,proto3,casttype=RequestID" json:"last_request_id,omitempty"`
	RequestFilter []byte    `protobuf:"bytes,3,opt,name=request_filter,json=requestFilter,proto3" json:"request_filter,omitempty"`
}

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

var xxx_messageInfo_KeepAliveRequest proto.InternalMessageInfo

func (m *KeepAliveRequest) GetSessionID() SessionID {
	if m != nil {
		return m.SessionID
	}
	return 0
}

func (m *KeepAliveRequest) GetLastRequestID() RequestID {
	if m != nil {
		return m.LastRequestID
	}
	return 0
}

func (m *KeepAliveRequest) GetRequestFilter() []byte {
	if m != nil {
		return m.RequestFilter
	}
	return nil
}

type KeepAliveResponse struct {
}

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

var xxx_messageInfo_KeepAliveResponse proto.InternalMessageInfo

type CloseSessionRequest struct {
	SessionID SessionID `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3,casttype=SessionID" json:"session_id,omitempty"`
}

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

var xxx_messageInfo_CloseSessionRequest proto.InternalMessageInfo

func (m *CloseSessionRequest) GetSessionID() SessionID {
	if m != nil {
		return m.SessionID
	}
	return 0
}

type CloseSessionResponse struct {
}

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

var xxx_messageInfo_CloseSessionResponse proto.InternalMessageInfo

type SessionCommandRequest struct {
	SessionID SessionID `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3,casttype=SessionID" json:"session_id,omitempty"`
	// Types that are valid to be assigned to Request:
	//	*SessionCommandRequest_CreateService
	//	*SessionCommandRequest_CloseService
	//	*SessionCommandRequest_ServiceCommand
	Request isSessionCommandRequest_Request `protobuf_oneof:"request"`
}

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

var xxx_messageInfo_SessionCommandRequest proto.InternalMessageInfo

type isSessionCommandRequest_Request interface {
	isSessionCommandRequest_Request()
	MarshalTo([]byte) (int, error)
	Size() int
}

type SessionCommandRequest_CreateService struct {
	CreateService *CreateServiceRequest `protobuf:"bytes,2,opt,name=create_service,json=createService,proto3,oneof" json:"create_service,omitempty"`
}
type SessionCommandRequest_CloseService struct {
	CloseService *CloseServiceRequest `protobuf:"bytes,3,opt,name=close_service,json=closeService,proto3,oneof" json:"close_service,omitempty"`
}
type SessionCommandRequest_ServiceCommand struct {
	ServiceCommand *ServiceCommandRequest `protobuf:"bytes,4,opt,name=service_command,json=serviceCommand,proto3,oneof" json:"service_command,omitempty"`
}

func (*SessionCommandRequest_CreateService) isSessionCommandRequest_Request()  {}
func (*SessionCommandRequest_CloseService) isSessionCommandRequest_Request()   {}
func (*SessionCommandRequest_ServiceCommand) isSessionCommandRequest_Request() {}

func (m *SessionCommandRequest) GetRequest() isSessionCommandRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *SessionCommandRequest) GetSessionID() SessionID {
	if m != nil {
		return m.SessionID
	}
	return 0
}

func (m *SessionCommandRequest) GetCreateService() *CreateServiceRequest {
	if x, ok := m.GetRequest().(*SessionCommandRequest_CreateService); ok {
		return x.CreateService
	}
	return nil
}

func (m *SessionCommandRequest) GetCloseService() *CloseServiceRequest {
	if x, ok := m.GetRequest().(*SessionCommandRequest_CloseService); ok {
		return x.CloseService
	}
	return nil
}

func (m *SessionCommandRequest) GetServiceCommand() *ServiceCommandRequest {
	if x, ok := m.GetRequest().(*SessionCommandRequest_ServiceCommand); ok {
		return x.ServiceCommand
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SessionCommandRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SessionCommandRequest_CreateService)(nil),
		(*SessionCommandRequest_CloseService)(nil),
		(*SessionCommandRequest_ServiceCommand)(nil),
	}
}

type SessionCommandResponse struct {
	// Types that are valid to be assigned to Response:
	//	*SessionCommandResponse_CreateService
	//	*SessionCommandResponse_CloseService
	//	*SessionCommandResponse_ServiceCommand
	Response isSessionCommandResponse_Response `protobuf_oneof:"response"`
}

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

var xxx_messageInfo_SessionCommandResponse proto.InternalMessageInfo

type isSessionCommandResponse_Response interface {
	isSessionCommandResponse_Response()
	MarshalTo([]byte) (int, error)
	Size() int
}

type SessionCommandResponse_CreateService struct {
	CreateService *CreateServiceResponse `protobuf:"bytes,1,opt,name=create_service,json=createService,proto3,oneof" json:"create_service,omitempty"`
}
type SessionCommandResponse_CloseService struct {
	CloseService *CloseServiceResponse `protobuf:"bytes,2,opt,name=close_service,json=closeService,proto3,oneof" json:"close_service,omitempty"`
}
type SessionCommandResponse_ServiceCommand struct {
	ServiceCommand *ServiceCommandResponse `protobuf:"bytes,3,opt,name=service_command,json=serviceCommand,proto3,oneof" json:"service_command,omitempty"`
}

func (*SessionCommandResponse_CreateService) isSessionCommandResponse_Response()  {}
func (*SessionCommandResponse_CloseService) isSessionCommandResponse_Response()   {}
func (*SessionCommandResponse_ServiceCommand) isSessionCommandResponse_Response() {}

func (m *SessionCommandResponse) GetResponse() isSessionCommandResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *SessionCommandResponse) GetCreateService() *CreateServiceResponse {
	if x, ok := m.GetResponse().(*SessionCommandResponse_CreateService); ok {
		return x.CreateService
	}
	return nil
}

func (m *SessionCommandResponse) GetCloseService() *CloseServiceResponse {
	if x, ok := m.GetResponse().(*SessionCommandResponse_CloseService); ok {
		return x.CloseService
	}
	return nil
}

func (m *SessionCommandResponse) GetServiceCommand() *ServiceCommandResponse {
	if x, ok := m.GetResponse().(*SessionCommandResponse_ServiceCommand); ok {
		return x.ServiceCommand
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SessionCommandResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SessionCommandResponse_CreateService)(nil),
		(*SessionCommandResponse_CloseService)(nil),
		(*SessionCommandResponse_ServiceCommand)(nil),
	}
}

type CreateServiceRequest struct {
	ServiceInfo `protobuf:"bytes,1,opt,name=info,proto3,embedded=info" json:"info"`
}

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

var xxx_messageInfo_CreateServiceRequest proto.InternalMessageInfo

type CreateServiceResponse struct {
	ServiceID ServiceID `protobuf:"varint,1,opt,name=service_id,json=serviceId,proto3,casttype=ServiceID" json:"service_id,omitempty"`
}

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

var xxx_messageInfo_CreateServiceResponse proto.InternalMessageInfo

func (m *CreateServiceResponse) GetServiceID() ServiceID {
	if m != nil {
		return m.ServiceID
	}
	return 0
}

type CloseServiceRequest struct {
	ServiceID ServiceID `protobuf:"varint,1,opt,name=service_id,json=serviceId,proto3,casttype=ServiceID" json:"service_id,omitempty"`
}

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

var xxx_messageInfo_CloseServiceRequest proto.InternalMessageInfo

func (m *CloseServiceRequest) GetServiceID() ServiceID {
	if m != nil {
		return m.ServiceID
	}
	return 0
}

type CloseServiceResponse struct {
}

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

var xxx_messageInfo_CloseServiceResponse proto.InternalMessageInfo

type ServiceCommandRequest struct {
	ServiceID ServiceID         `protobuf:"varint,1,opt,name=service_id,json=serviceId,proto3,casttype=ServiceID" json:"service_id,omitempty"`
	RequestID RequestID         `protobuf:"varint,2,opt,name=request_id,json=requestId,proto3,casttype=RequestID" json:"request_id,omitempty"`
	Operation *OperationRequest `protobuf:"bytes,3,opt,name=operation,proto3" json:"operation,omitempty"`
}

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

var xxx_messageInfo_ServiceCommandRequest proto.InternalMessageInfo

func (m *ServiceCommandRequest) GetServiceID() ServiceID {
	if m != nil {
		return m.ServiceID
	}
	return 0
}

func (m *ServiceCommandRequest) GetRequestID() RequestID {
	if m != nil {
		return m.RequestID
	}
	return 0
}

func (m *ServiceCommandRequest) GetOperation() *OperationRequest {
	if m != nil {
		return m.Operation
	}
	return nil
}

type ServiceCommandResponse struct {
	ResponseID ResponseID         `protobuf:"varint,1,opt,name=response_id,json=responseId,proto3,casttype=ResponseID" json:"response_id,omitempty"`
	Operation  *OperationResponse `protobuf:"bytes,2,opt,name=operation,proto3" json:"operation,omitempty"`
}

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

var xxx_messageInfo_ServiceCommandResponse proto.InternalMessageInfo

func (m *ServiceCommandResponse) GetResponseID() ResponseID {
	if m != nil {
		return m.ResponseID
	}
	return 0
}

func (m *ServiceCommandResponse) GetOperation() *OperationResponse {
	if m != nil {
		return m.Operation
	}
	return nil
}

type PartitionQueryRequest struct {
	PartitionID PartitionID  `protobuf:"varint,1,opt,name=partition_id,json=partitionId,proto3,casttype=PartitionID" json:"partition_id,omitempty"`
	Request     QueryRequest `protobuf:"bytes,2,opt,name=request,proto3" json:"request"`
	Sync        bool         `protobuf:"varint,3,opt,name=sync,proto3" json:"sync,omitempty"`
}

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

var xxx_messageInfo_PartitionQueryRequest proto.InternalMessageInfo

func (m *PartitionQueryRequest) GetPartitionID() PartitionID {
	if m != nil {
		return m.PartitionID
	}
	return 0
}

func (m *PartitionQueryRequest) GetRequest() QueryRequest {
	if m != nil {
		return m.Request
	}
	return QueryRequest{}
}

func (m *PartitionQueryRequest) GetSync() bool {
	if m != nil {
		return m.Sync
	}
	return false
}

type PartitionQueryResponse struct {
	Response QueryResponse `protobuf:"bytes,1,opt,name=response,proto3" json:"response"`
}

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

var xxx_messageInfo_PartitionQueryResponse proto.InternalMessageInfo

func (m *PartitionQueryResponse) GetResponse() QueryResponse {
	if m != nil {
		return m.Response
	}
	return QueryResponse{}
}

type QueryRequest struct {
	LastIndex Index `protobuf:"varint,1,opt,name=last_index,json=lastIndex,proto3,casttype=Index" json:"last_index,omitempty"`
	// Types that are valid to be assigned to Request:
	//	*QueryRequest_SessionQuery
	Request isQueryRequest_Request `protobuf_oneof:"request"`
}

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

var xxx_messageInfo_QueryRequest proto.InternalMessageInfo

type isQueryRequest_Request interface {
	isQueryRequest_Request()
	MarshalTo([]byte) (int, error)
	Size() int
}

type QueryRequest_SessionQuery struct {
	SessionQuery *SessionQueryRequest `protobuf:"bytes,2,opt,name=session_query,json=sessionQuery,proto3,oneof" json:"session_query,omitempty"`
}

func (*QueryRequest_SessionQuery) isQueryRequest_Request() {}

func (m *QueryRequest) GetRequest() isQueryRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *QueryRequest) GetLastIndex() Index {
	if m != nil {
		return m.LastIndex
	}
	return 0
}

func (m *QueryRequest) GetSessionQuery() *SessionQueryRequest {
	if x, ok := m.GetRequest().(*QueryRequest_SessionQuery); ok {
		return x.SessionQuery
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*QueryRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*QueryRequest_SessionQuery)(nil),
	}
}

type QueryResponse struct {
	// Types that are valid to be assigned to Response:
	//	*QueryResponse_SessionQuery
	Response isQueryResponse_Response `protobuf_oneof:"response"`
}

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

var xxx_messageInfo_QueryResponse proto.InternalMessageInfo

type isQueryResponse_Response interface {
	isQueryResponse_Response()
	MarshalTo([]byte) (int, error)
	Size() int
}

type QueryResponse_SessionQuery struct {
	SessionQuery *SessionQueryResponse `protobuf:"bytes,1,opt,name=session_query,json=sessionQuery,proto3,oneof" json:"session_query,omitempty"`
}

func (*QueryResponse_SessionQuery) isQueryResponse_Response() {}

func (m *QueryResponse) GetResponse() isQueryResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *QueryResponse) GetSessionQuery() *SessionQueryResponse {
	if x, ok := m.GetResponse().(*QueryResponse_SessionQuery); ok {
		return x.SessionQuery
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*QueryResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*QueryResponse_SessionQuery)(nil),
	}
}

type SessionQueryRequest struct {
	SessionID SessionID `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3,casttype=SessionID" json:"session_id,omitempty"`
	// Types that are valid to be assigned to Request:
	//	*SessionQueryRequest_ServiceQuery
	Request isSessionQueryRequest_Request `protobuf_oneof:"request"`
}

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

var xxx_messageInfo_SessionQueryRequest proto.InternalMessageInfo

type isSessionQueryRequest_Request interface {
	isSessionQueryRequest_Request()
	MarshalTo([]byte) (int, error)
	Size() int
}

type SessionQueryRequest_ServiceQuery struct {
	ServiceQuery *ServiceQueryRequest `protobuf:"bytes,2,opt,name=service_query,json=serviceQuery,proto3,oneof" json:"service_query,omitempty"`
}

func (*SessionQueryRequest_ServiceQuery) isSessionQueryRequest_Request() {}

func (m *SessionQueryRequest) GetRequest() isSessionQueryRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *SessionQueryRequest) GetSessionID() SessionID {
	if m != nil {
		return m.SessionID
	}
	return 0
}

func (m *SessionQueryRequest) GetServiceQuery() *ServiceQueryRequest {
	if x, ok := m.GetRequest().(*SessionQueryRequest_ServiceQuery); ok {
		return x.ServiceQuery
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SessionQueryRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SessionQueryRequest_ServiceQuery)(nil),
	}
}

type SessionQueryResponse struct {
	// Types that are valid to be assigned to Response:
	//	*SessionQueryResponse_ServiceQuery
	Response isSessionQueryResponse_Response `protobuf_oneof:"response"`
}

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

var xxx_messageInfo_SessionQueryResponse proto.InternalMessageInfo

type isSessionQueryResponse_Response interface {
	isSessionQueryResponse_Response()
	MarshalTo([]byte) (int, error)
	Size() int
}

type SessionQueryResponse_ServiceQuery struct {
	ServiceQuery *ServiceQueryResponse `protobuf:"bytes,2,opt,name=service_query,json=serviceQuery,proto3,oneof" json:"service_query,omitempty"`
}

func (*SessionQueryResponse_ServiceQuery) isSessionQueryResponse_Response() {}

func (m *SessionQueryResponse) GetResponse() isSessionQueryResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *SessionQueryResponse) GetServiceQuery() *ServiceQueryResponse {
	if x, ok := m.GetResponse().(*SessionQueryResponse_ServiceQuery); ok {
		return x.ServiceQuery
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SessionQueryResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SessionQueryResponse_ServiceQuery)(nil),
	}
}

type ServiceQueryRequest struct {
	ServiceID ServiceID         `protobuf:"varint,1,opt,name=service_id,json=serviceId,proto3,casttype=ServiceID" json:"service_id,omitempty"`
	Operation *OperationRequest `protobuf:"bytes,2,opt,name=operation,proto3" json:"operation,omitempty"`
}

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

var xxx_messageInfo_ServiceQueryRequest proto.InternalMessageInfo

func (m *ServiceQueryRequest) GetServiceID() ServiceID {
	if m != nil {
		return m.ServiceID
	}
	return 0
}

func (m *ServiceQueryRequest) GetOperation() *OperationRequest {
	if m != nil {
		return m.Operation
	}
	return nil
}

type ServiceQueryResponse struct {
	ResponseID ResponseID         `protobuf:"varint,1,opt,name=response_id,json=responseId,proto3,casttype=ResponseID" json:"response_id,omitempty"`
	Operation  *OperationResponse `protobuf:"bytes,2,opt,name=operation,proto3" json:"operation,omitempty"`
}

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

var xxx_messageInfo_ServiceQueryResponse proto.InternalMessageInfo

func (m *ServiceQueryResponse) GetResponseID() ResponseID {
	if m != nil {
		return m.ResponseID
	}
	return 0
}

func (m *ServiceQueryResponse) GetOperation() *OperationResponse {
	if m != nil {
		return m.Operation
	}
	return nil
}

type OperationRequest struct {
	OperationID OperationID `protobuf:"varint,1,opt,name=operation_id,json=operationId,proto3,casttype=OperationID" json:"operation_id,omitempty"`
	Value       []byte      `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_OperationRequest proto.InternalMessageInfo

func (m *OperationRequest) GetOperationID() OperationID {
	if m != nil {
		return m.OperationID
	}
	return 0
}

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

type OperationResponse struct {
	Status ResponseStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status"`
	Value  []byte         `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_OperationResponse proto.InternalMessageInfo

func (m *OperationResponse) GetStatus() ResponseStatus {
	if m != nil {
		return m.Status
	}
	return ResponseStatus{}
}

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

type ResponseStatus struct {
	Code    ResponseCode `protobuf:"varint,1,opt,name=code,proto3,enum=atomix.service.ResponseCode" json:"code,omitempty"`
	Message string       `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_ResponseStatus proto.InternalMessageInfo

func (m *ResponseStatus) GetCode() ResponseCode {
	if m != nil {
		return m.Code
	}
	return ResponseCode_OK
}

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

func init() {
	proto.RegisterEnum("atomix.service.SessionCommandState", SessionCommandState_name, SessionCommandState_value)
	proto.RegisterEnum("atomix.service.ResponseCode", ResponseCode_name, ResponseCode_value)
	proto.RegisterType((*StateMachineSnapshot)(nil), "atomix.service.StateMachineSnapshot")
	proto.RegisterType((*SessionSnapshot)(nil), "atomix.service.SessionSnapshot")
	proto.RegisterType((*SessionCommandSnapshot)(nil), "atomix.service.SessionCommandSnapshot")
	proto.RegisterType((*ServiceSnapshot)(nil), "atomix.service.ServiceSnapshot")
	proto.RegisterType((*ServiceSessionSnapshot)(nil), "atomix.service.ServiceSessionSnapshot")
	proto.RegisterType((*ServiceInfo)(nil), "atomix.service.ServiceInfo")
	proto.RegisterType((*PartitionConfigRequest)(nil), "atomix.service.PartitionConfigRequest")
	proto.RegisterType((*PartitionConfigResponse)(nil), "atomix.service.PartitionConfigResponse")
	proto.RegisterType((*PartitionCommandRequest)(nil), "atomix.service.PartitionCommandRequest")
	proto.RegisterType((*PartitionCommandResponse)(nil), "atomix.service.PartitionCommandResponse")
	proto.RegisterType((*CommandRequest)(nil), "atomix.service.CommandRequest")
	proto.RegisterType((*CommandResponse)(nil), "atomix.service.CommandResponse")
	proto.RegisterType((*OpenSessionRequest)(nil), "atomix.service.OpenSessionRequest")
	proto.RegisterType((*OpenSessionResponse)(nil), "atomix.service.OpenSessionResponse")
	proto.RegisterType((*KeepAliveRequest)(nil), "atomix.service.KeepAliveRequest")
	proto.RegisterType((*KeepAliveResponse)(nil), "atomix.service.KeepAliveResponse")
	proto.RegisterType((*CloseSessionRequest)(nil), "atomix.service.CloseSessionRequest")
	proto.RegisterType((*CloseSessionResponse)(nil), "atomix.service.CloseSessionResponse")
	proto.RegisterType((*SessionCommandRequest)(nil), "atomix.service.SessionCommandRequest")
	proto.RegisterType((*SessionCommandResponse)(nil), "atomix.service.SessionCommandResponse")
	proto.RegisterType((*CreateServiceRequest)(nil), "atomix.service.CreateServiceRequest")
	proto.RegisterType((*CreateServiceResponse)(nil), "atomix.service.CreateServiceResponse")
	proto.RegisterType((*CloseServiceRequest)(nil), "atomix.service.CloseServiceRequest")
	proto.RegisterType((*CloseServiceResponse)(nil), "atomix.service.CloseServiceResponse")
	proto.RegisterType((*ServiceCommandRequest)(nil), "atomix.service.ServiceCommandRequest")
	proto.RegisterType((*ServiceCommandResponse)(nil), "atomix.service.ServiceCommandResponse")
	proto.RegisterType((*PartitionQueryRequest)(nil), "atomix.service.PartitionQueryRequest")
	proto.RegisterType((*PartitionQueryResponse)(nil), "atomix.service.PartitionQueryResponse")
	proto.RegisterType((*QueryRequest)(nil), "atomix.service.QueryRequest")
	proto.RegisterType((*QueryResponse)(nil), "atomix.service.QueryResponse")
	proto.RegisterType((*SessionQueryRequest)(nil), "atomix.service.SessionQueryRequest")
	proto.RegisterType((*SessionQueryResponse)(nil), "atomix.service.SessionQueryResponse")
	proto.RegisterType((*ServiceQueryRequest)(nil), "atomix.service.ServiceQueryRequest")
	proto.RegisterType((*ServiceQueryResponse)(nil), "atomix.service.ServiceQueryResponse")
	proto.RegisterType((*OperationRequest)(nil), "atomix.service.OperationRequest")
	proto.RegisterType((*OperationResponse)(nil), "atomix.service.OperationResponse")
	proto.RegisterType((*ResponseStatus)(nil), "atomix.service.ResponseStatus")
}

func init() {
	proto.RegisterFile("atomix/storage/protocol/rsm/service.proto", fileDescriptor_e3f642df445f73e7)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// PartitionServiceClient is the client API for PartitionService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PartitionServiceClient interface {
	WatchConfig(ctx context.Context, in *PartitionConfigRequest, opts ...grpc.CallOption) (PartitionService_WatchConfigClient, error)
	Query(ctx context.Context, in *PartitionQueryRequest, opts ...grpc.CallOption) (*PartitionQueryResponse, error)
	QueryStream(ctx context.Context, in *PartitionQueryRequest, opts ...grpc.CallOption) (PartitionService_QueryStreamClient, error)
	Command(ctx context.Context, in *PartitionCommandRequest, opts ...grpc.CallOption) (*PartitionCommandResponse, error)
	CommandStream(ctx context.Context, in *PartitionCommandRequest, opts ...grpc.CallOption) (PartitionService_CommandStreamClient, error)
}

type partitionServiceClient struct {
	cc *grpc.ClientConn
}

func NewPartitionServiceClient(cc *grpc.ClientConn) PartitionServiceClient {
	return &partitionServiceClient{cc}
}

func (c *partitionServiceClient) WatchConfig(ctx context.Context, in *PartitionConfigRequest, opts ...grpc.CallOption) (PartitionService_WatchConfigClient, error) {
	stream, err := c.cc.NewStream(ctx, &_PartitionService_serviceDesc.Streams[0], "/atomix.service.PartitionService/WatchConfig", opts...)
	if err != nil {
		return nil, err
	}
	x := &partitionServiceWatchConfigClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type PartitionService_WatchConfigClient interface {
	Recv() (*PartitionConfigResponse, error)
	grpc.ClientStream
}

type partitionServiceWatchConfigClient struct {
	grpc.ClientStream
}

func (x *partitionServiceWatchConfigClient) Recv() (*PartitionConfigResponse, error) {
	m := new(PartitionConfigResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *partitionServiceClient) Query(ctx context.Context, in *PartitionQueryRequest, opts ...grpc.CallOption) (*PartitionQueryResponse, error) {
	out := new(PartitionQueryResponse)
	err := c.cc.Invoke(ctx, "/atomix.service.PartitionService/Query", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *partitionServiceClient) QueryStream(ctx context.Context, in *PartitionQueryRequest, opts ...grpc.CallOption) (PartitionService_QueryStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_PartitionService_serviceDesc.Streams[1], "/atomix.service.PartitionService/QueryStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &partitionServiceQueryStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type PartitionService_QueryStreamClient interface {
	Recv() (*PartitionQueryResponse, error)
	grpc.ClientStream
}

type partitionServiceQueryStreamClient struct {
	grpc.ClientStream
}

func (x *partitionServiceQueryStreamClient) Recv() (*PartitionQueryResponse, error) {
	m := new(PartitionQueryResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *partitionServiceClient) Command(ctx context.Context, in *PartitionCommandRequest, opts ...grpc.CallOption) (*PartitionCommandResponse, error) {
	out := new(PartitionCommandResponse)
	err := c.cc.Invoke(ctx, "/atomix.service.PartitionService/Command", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *partitionServiceClient) CommandStream(ctx context.Context, in *PartitionCommandRequest, opts ...grpc.CallOption) (PartitionService_CommandStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_PartitionService_serviceDesc.Streams[2], "/atomix.service.PartitionService/CommandStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &partitionServiceCommandStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type PartitionService_CommandStreamClient interface {
	Recv() (*PartitionCommandResponse, error)
	grpc.ClientStream
}

type partitionServiceCommandStreamClient struct {
	grpc.ClientStream
}

func (x *partitionServiceCommandStreamClient) Recv() (*PartitionCommandResponse, error) {
	m := new(PartitionCommandResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// PartitionServiceServer is the server API for PartitionService service.
type PartitionServiceServer interface {
	WatchConfig(*PartitionConfigRequest, PartitionService_WatchConfigServer) error
	Query(context.Context, *PartitionQueryRequest) (*PartitionQueryResponse, error)
	QueryStream(*PartitionQueryRequest, PartitionService_QueryStreamServer) error
	Command(context.Context, *PartitionCommandRequest) (*PartitionCommandResponse, error)
	CommandStream(*PartitionCommandRequest, PartitionService_CommandStreamServer) error
}

// UnimplementedPartitionServiceServer can be embedded to have forward compatible implementations.
type UnimplementedPartitionServiceServer struct {
}

func (*UnimplementedPartitionServiceServer) WatchConfig(req *PartitionConfigRequest, srv PartitionService_WatchConfigServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchConfig not implemented")
}
func (*UnimplementedPartitionServiceServer) Query(ctx context.Context, req *PartitionQueryRequest) (*PartitionQueryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Query not implemented")
}
func (*UnimplementedPartitionServiceServer) QueryStream(req *PartitionQueryRequest, srv PartitionService_QueryStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method QueryStream not implemented")
}
func (*UnimplementedPartitionServiceServer) Command(ctx context.Context, req *PartitionCommandRequest) (*PartitionCommandResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Command not implemented")
}
func (*UnimplementedPartitionServiceServer) CommandStream(req *PartitionCommandRequest, srv PartitionService_CommandStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method CommandStream not implemented")
}

func RegisterPartitionServiceServer(s *grpc.Server, srv PartitionServiceServer) {
	s.RegisterService(&_PartitionService_serviceDesc, srv)
}

func _PartitionService_WatchConfig_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PartitionConfigRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PartitionServiceServer).WatchConfig(m, &partitionServiceWatchConfigServer{stream})
}

type PartitionService_WatchConfigServer interface {
	Send(*PartitionConfigResponse) error
	grpc.ServerStream
}

type partitionServiceWatchConfigServer struct {
	grpc.ServerStream
}

func (x *partitionServiceWatchConfigServer) Send(m *PartitionConfigResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _PartitionService_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PartitionQueryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PartitionServiceServer).Query(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/atomix.service.PartitionService/Query",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PartitionServiceServer).Query(ctx, req.(*PartitionQueryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PartitionService_QueryStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PartitionQueryRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PartitionServiceServer).QueryStream(m, &partitionServiceQueryStreamServer{stream})
}

type PartitionService_QueryStreamServer interface {
	Send(*PartitionQueryResponse) error
	grpc.ServerStream
}

type partitionServiceQueryStreamServer struct {
	grpc.ServerStream
}

func (x *partitionServiceQueryStreamServer) Send(m *PartitionQueryResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _PartitionService_Command_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PartitionCommandRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PartitionServiceServer).Command(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/atomix.service.PartitionService/Command",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PartitionServiceServer).Command(ctx, req.(*PartitionCommandRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PartitionService_CommandStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PartitionCommandRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PartitionServiceServer).CommandStream(m, &partitionServiceCommandStreamServer{stream})
}

type PartitionService_CommandStreamServer interface {
	Send(*PartitionCommandResponse) error
	grpc.ServerStream
}

type partitionServiceCommandStreamServer struct {
	grpc.ServerStream
}

func (x *partitionServiceCommandStreamServer) Send(m *PartitionCommandResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _PartitionService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "atomix.service.PartitionService",
	HandlerType: (*PartitionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Query",
			Handler:    _PartitionService_Query_Handler,
		},
		{
			MethodName: "Command",
			Handler:    _PartitionService_Command_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchConfig",
			Handler:       _PartitionService_WatchConfig_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "QueryStream",
			Handler:       _PartitionService_QueryStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CommandStream",
			Handler:       _PartitionService_CommandStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "atomix/storage/protocol/rsm/service.proto",
}

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

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

func (m *StateMachineSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Services) > 0 {
		for iNdEx := len(m.Services) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Services[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Sessions) > 0 {
		for iNdEx := len(m.Sessions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sessions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintService(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x12
	if m.Index != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SessionSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastUpdated, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastUpdated):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintService(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x1a
	n3, err3 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Timeout, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Timeout):])
	if err3 != nil {
		return 0, err3
	}
	i -= n3
	i = encodeVarintService(dAtA, i, uint64(n3))
	i--
	dAtA[i] = 0x12
	if m.SessionID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.SessionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SessionCommandSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PendingResponses) > 0 {
		for iNdEx := len(m.PendingResponses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PendingResponses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Request != nil {
		{
			size, err := m.Request.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.State != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	if m.CommandID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.CommandID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ServiceSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sessions) > 0 {
		for iNdEx := len(m.Sessions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sessions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintService(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.ServiceInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintService(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ServiceID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.ServiceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ServiceSessionSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Commands) > 0 {
		for iNdEx := len(m.Commands) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Commands[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.SessionID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.SessionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ServiceInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintService(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintService(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintService(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *PartitionConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Followers) > 0 {
		for iNdEx := len(m.Followers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Followers[iNdEx])
			copy(dAtA[i:], m.Followers[iNdEx])
			i = encodeVarintService(dAtA, i, uint64(len(m.Followers[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Leader) > 0 {
		i -= len(m.Leader)
		copy(dAtA[i:], m.Leader)
		i = encodeVarintService(dAtA, i, uint64(len(m.Leader)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *PartitionCommandRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Request.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintService(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.PartitionID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.PartitionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *CommandRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Request != nil {
		{
			size := m.Request.Size()
			i -= size
			if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Timestamp != nil {
		n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp):])
		if err8 != nil {
			return 0, err8
		}
		i -= n8
		i = encodeVarintService(dAtA, i, uint64(n8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CommandRequest_OpenSession) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.OpenSession != nil {
		{
			size, err := m.OpenSession.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *CommandRequest_KeepAlive) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommandRequest_KeepAlive) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.KeepAlive != nil {
		{
			size, err := m.KeepAlive.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *CommandRequest_CloseSession) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommandRequest_CloseSession) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CloseSession != nil {
		{
			size, err := m.CloseSession.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *CommandRequest_SessionCommand) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommandRequest_SessionCommand) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SessionCommand != nil {
		{
			size, err := m.SessionCommand.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *CommandResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *CommandResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != nil {
		{
			size := m.Response.Size()
			i -= size
			if _, err := m.Response.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Index != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CommandResponse_OpenSession) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.OpenSession != nil {
		{
			size, err := m.OpenSession.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *CommandResponse_KeepAlive) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommandResponse_KeepAlive) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.KeepAlive != nil {
		{
			size, err := m.KeepAlive.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *CommandResponse_CloseSession) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommandResponse_CloseSession) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CloseSession != nil {
		{
			size, err := m.CloseSession.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *CommandResponse_SessionCommand) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommandResponse_SessionCommand) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SessionCommand != nil {
		{
			size, err := m.SessionCommand.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *OpenSessionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *OpenSessionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n17, err17 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Timeout, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Timeout):])
	if err17 != nil {
		return 0, err17
	}
	i -= n17
	i = encodeVarintService(dAtA, i, uint64(n17))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *KeepAliveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RequestFilter) > 0 {
		i -= len(m.RequestFilter)
		copy(dAtA[i:], m.RequestFilter)
		i = encodeVarintService(dAtA, i, uint64(len(m.RequestFilter)))
		i--
		dAtA[i] = 0x1a
	}
	if m.LastRequestID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.LastRequestID))
		i--
		dAtA[i] = 0x10
	}
	if m.SessionID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.SessionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *SessionCommandRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Request != nil {
		{
			size := m.Request.Size()
			i -= size
			if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.SessionID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.SessionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SessionCommandRequest_CreateService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CreateService != nil {
		{
			size, err := m.CreateService.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *SessionCommandRequest_CloseService) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionCommandRequest_CloseService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CloseService != nil {
		{
			size, err := m.CloseService.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *SessionCommandRequest_ServiceCommand) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionCommandRequest_ServiceCommand) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ServiceCommand != nil {
		{
			size, err := m.ServiceCommand.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *SessionCommandResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *SessionCommandResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != nil {
		{
			size := m.Response.Size()
			i -= size
			if _, err := m.Response.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SessionCommandResponse_CreateService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CreateService != nil {
		{
			size, err := m.CreateService.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *SessionCommandResponse_CloseService) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionCommandResponse_CloseService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CloseService != nil {
		{
			size, err := m.CloseService.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *SessionCommandResponse_ServiceCommand) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionCommandResponse_ServiceCommand) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ServiceCommand != nil {
		{
			size, err := m.ServiceCommand.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *CreateServiceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *ServiceCommandRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Operation != nil {
		{
			size, err := m.Operation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.RequestID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.RequestID))
		i--
		dAtA[i] = 0x10
	}
	if m.ServiceID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.ServiceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ServiceCommandResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Operation != nil {
		{
			size, err := m.Operation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ResponseID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.ResponseID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *PartitionQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sync {
		i--
		if m.Sync {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.Request.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintService(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.PartitionID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.PartitionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *QueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Request != nil {
		{
			size := m.Request.Size()
			i -= size
			if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.LastIndex != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.LastIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryRequest_SessionQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SessionQuery != nil {
		{
			size, err := m.SessionQuery.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *QueryResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *QueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != nil {
		{
			size := m.Response.Size()
			i -= size
			if _, err := m.Response.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryResponse_SessionQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SessionQuery != nil {
		{
			size, err := m.SessionQuery.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *SessionQueryRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *SessionQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Request != nil {
		{
			size := m.Request.Size()
			i -= size
			if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.SessionID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.SessionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SessionQueryRequest_ServiceQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ServiceQuery != nil {
		{
			size, err := m.ServiceQuery.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *SessionQueryResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *SessionQueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != nil {
		{
			size := m.Response.Size()
			i -= size
			if _, err := m.Response.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SessionQueryResponse_ServiceQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ServiceQuery != nil {
		{
			size, err := m.ServiceQuery.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *ServiceQueryRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *ServiceQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Operation != nil {
		{
			size, err := m.Operation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ServiceID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.ServiceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ServiceQueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Operation != nil {
		{
			size, err := m.Operation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ResponseID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.ResponseID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *OperationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintService(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintService(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func encodeVarintService(dAtA []byte, offset int, v uint64) int {
	offset -= sovService(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *StateMachineSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovService(uint64(m.Index))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
	n += 1 + l + sovService(uint64(l))
	if len(m.Sessions) > 0 {
		for _, e := range m.Sessions {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	if len(m.Services) > 0 {
		for _, e := range m.Services {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *SessionSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionID != 0 {
		n += 1 + sovService(uint64(m.SessionID))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Timeout)
	n += 1 + l + sovService(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.LastUpdated)
	n += 1 + l + sovService(uint64(l))
	return n
}

func (m *SessionCommandSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CommandID != 0 {
		n += 1 + sovService(uint64(m.CommandID))
	}
	if m.State != 0 {
		n += 1 + sovService(uint64(m.State))
	}
	if m.Request != nil {
		l = m.Request.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.PendingResponses) > 0 {
		for _, e := range m.PendingResponses {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *ServiceSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceID != 0 {
		n += 1 + sovService(uint64(m.ServiceID))
	}
	l = m.ServiceInfo.Size()
	n += 1 + l + sovService(uint64(l))
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.Sessions) > 0 {
		for _, e := range m.Sessions {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *ServiceSessionSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionID != 0 {
		n += 1 + sovService(uint64(m.SessionID))
	}
	if len(m.Commands) > 0 {
		for _, e := range m.Commands {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *ServiceInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *PartitionConfigRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PartitionID != 0 {
		n += 1 + sovService(uint64(m.PartitionID))
	}
	return n
}

func (m *PartitionConfigResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Leader)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.Followers) > 0 {
		for _, s := range m.Followers {
			l = len(s)
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *PartitionCommandRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PartitionID != 0 {
		n += 1 + sovService(uint64(m.PartitionID))
	}
	l = m.Request.Size()
	n += 1 + l + sovService(uint64(l))
	return n
}

func (m *PartitionCommandResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Response.Size()
	n += 1 + l + sovService(uint64(l))
	return n
}

func (m *CommandRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Timestamp != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp)
		n += 1 + l + sovService(uint64(l))
	}
	if m.Request != nil {
		n += m.Request.Size()
	}
	return n
}

func (m *CommandRequest_OpenSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OpenSession != nil {
		l = m.OpenSession.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *CommandRequest_KeepAlive) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.KeepAlive != nil {
		l = m.KeepAlive.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *CommandRequest_CloseSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CloseSession != nil {
		l = m.CloseSession.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *CommandRequest_SessionCommand) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionCommand != nil {
		l = m.SessionCommand.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *CommandResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovService(uint64(m.Index))
	}
	if m.Response != nil {
		n += m.Response.Size()
	}
	return n
}

func (m *CommandResponse_OpenSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OpenSession != nil {
		l = m.OpenSession.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *CommandResponse_KeepAlive) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.KeepAlive != nil {
		l = m.KeepAlive.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *CommandResponse_CloseSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CloseSession != nil {
		l = m.CloseSession.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *CommandResponse_SessionCommand) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionCommand != nil {
		l = m.SessionCommand.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *OpenSessionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Timeout)
	n += 1 + l + sovService(uint64(l))
	return n
}

func (m *OpenSessionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionID != 0 {
		n += 1 + sovService(uint64(m.SessionID))
	}
	return n
}

func (m *KeepAliveRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionID != 0 {
		n += 1 + sovService(uint64(m.SessionID))
	}
	if m.LastRequestID != 0 {
		n += 1 + sovService(uint64(m.LastRequestID))
	}
	l = len(m.RequestFilter)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

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

func (m *CloseSessionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionID != 0 {
		n += 1 + sovService(uint64(m.SessionID))
	}
	return n
}

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

func (m *SessionCommandRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionID != 0 {
		n += 1 + sovService(uint64(m.SessionID))
	}
	if m.Request != nil {
		n += m.Request.Size()
	}
	return n
}

func (m *SessionCommandRequest_CreateService) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateService != nil {
		l = m.CreateService.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionCommandRequest_CloseService) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CloseService != nil {
		l = m.CloseService.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionCommandRequest_ServiceCommand) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceCommand != nil {
		l = m.ServiceCommand.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionCommandResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Response != nil {
		n += m.Response.Size()
	}
	return n
}

func (m *SessionCommandResponse_CreateService) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateService != nil {
		l = m.CreateService.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionCommandResponse_CloseService) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CloseService != nil {
		l = m.CloseService.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionCommandResponse_ServiceCommand) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceCommand != nil {
		l = m.ServiceCommand.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *CreateServiceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ServiceInfo.Size()
	n += 1 + l + sovService(uint64(l))
	return n
}

func (m *CreateServiceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceID != 0 {
		n += 1 + sovService(uint64(m.ServiceID))
	}
	return n
}

func (m *CloseServiceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceID != 0 {
		n += 1 + sovService(uint64(m.ServiceID))
	}
	return n
}

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

func (m *ServiceCommandRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceID != 0 {
		n += 1 + sovService(uint64(m.ServiceID))
	}
	if m.RequestID != 0 {
		n += 1 + sovService(uint64(m.RequestID))
	}
	if m.Operation != nil {
		l = m.Operation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *ServiceCommandResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResponseID != 0 {
		n += 1 + sovService(uint64(m.ResponseID))
	}
	if m.Operation != nil {
		l = m.Operation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *PartitionQueryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PartitionID != 0 {
		n += 1 + sovService(uint64(m.PartitionID))
	}
	l = m.Request.Size()
	n += 1 + l + sovService(uint64(l))
	if m.Sync {
		n += 2
	}
	return n
}

func (m *PartitionQueryResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Response.Size()
	n += 1 + l + sovService(uint64(l))
	return n
}

func (m *QueryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LastIndex != 0 {
		n += 1 + sovService(uint64(m.LastIndex))
	}
	if m.Request != nil {
		n += m.Request.Size()
	}
	return n
}

func (m *QueryRequest_SessionQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionQuery != nil {
		l = m.SessionQuery.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *QueryResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Response != nil {
		n += m.Response.Size()
	}
	return n
}

func (m *QueryResponse_SessionQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionQuery != nil {
		l = m.SessionQuery.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionQueryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SessionID != 0 {
		n += 1 + sovService(uint64(m.SessionID))
	}
	if m.Request != nil {
		n += m.Request.Size()
	}
	return n
}

func (m *SessionQueryRequest_ServiceQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceQuery != nil {
		l = m.ServiceQuery.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionQueryResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Response != nil {
		n += m.Response.Size()
	}
	return n
}

func (m *SessionQueryResponse_ServiceQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceQuery != nil {
		l = m.ServiceQuery.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceQueryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceID != 0 {
		n += 1 + sovService(uint64(m.ServiceID))
	}
	if m.Operation != nil {
		l = m.Operation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *ServiceQueryResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResponseID != 0 {
		n += 1 + sovService(uint64(m.ResponseID))
	}
	if m.Operation != nil {
		l = m.Operation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *OperationRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OperationID != 0 {
		n += 1 + sovService(uint64(m.OperationID))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *OperationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Status.Size()
	n += 1 + l + sovService(uint64(l))
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *ResponseStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovService(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func sovService(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozService(x uint64) (n int) {
	return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *StateMachineSnapshot) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StateMachineSnapshot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StateMachineSnapshot: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sessions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sessions = append(m.Sessions, &SessionSnapshot{})
			if err := m.Sessions[len(m.Sessions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Services = append(m.Services, &ServiceSnapshot{})
			if err := m.Services[len(m.Services)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CommandRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CommandRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommandRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OpenSession", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OpenSessionRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &CommandRequest_OpenSession{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeepAlive", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &KeepAliveRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &CommandRequest_KeepAlive{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloseSession", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CloseSessionRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &CommandRequest_CloseSession{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionCommand", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SessionCommandRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &CommandRequest_SessionCommand{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CommandResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CommandResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommandResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OpenSession", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OpenSessionResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &CommandResponse_OpenSession{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeepAlive", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &KeepAliveResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &CommandResponse_KeepAlive{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloseSession", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CloseSessionResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &CommandResponse_CloseSession{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionCommand", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SessionCommandResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &CommandResponse_SessionCommand{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SessionCommandRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SessionCommandRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionCommandRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionID", wireType)
			}
			m.SessionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SessionID |= SessionID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CreateServiceRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &SessionCommandRequest_CreateService{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloseService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CloseServiceRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &SessionCommandRequest_CloseService{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceCommand", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ServiceCommandRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &SessionCommandRequest_ServiceCommand{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SessionCommandResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SessionCommandResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionCommandResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CreateServiceResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &SessionCommandResponse_CreateService{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloseService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CloseServiceResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &SessionCommandResponse_CloseService{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceCommand", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ServiceCommandResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &SessionCommandResponse_ServiceCommand{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var (
	ErrInvalidLengthService        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowService          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupService = fmt.Errorf("proto: unexpected end of group")
)