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 SessionResponseType int32

const (
	SessionResponseType_RESPONSE     SessionResponseType = 0
	SessionResponseType_OPEN_STREAM  SessionResponseType = 1
	SessionResponseType_CLOSE_STREAM SessionResponseType = 2
)

var SessionResponseType_name = map[int32]string{
	0: "RESPONSE",
	1: "OPEN_STREAM",
	2: "CLOSE_STREAM",
}

var SessionResponseType_value = map[string]int32{
	"RESPONSE":     0,
	"OPEN_STREAM":  1,
	"CLOSE_STREAM": 2,
}

func (x SessionResponseType) String() string {
	return proto.EnumName(SessionResponseType_name, int32(x))
}

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

type SessionResponseCode int32

const (
	SessionResponseCode_OK             SessionResponseCode = 0
	SessionResponseCode_ERROR          SessionResponseCode = 1
	SessionResponseCode_NOT_LEADER     SessionResponseCode = 2
	SessionResponseCode_UNKNOWN        SessionResponseCode = 3
	SessionResponseCode_CANCELED       SessionResponseCode = 4
	SessionResponseCode_NOT_FOUND      SessionResponseCode = 5
	SessionResponseCode_ALREADY_EXISTS SessionResponseCode = 6
	SessionResponseCode_UNAUTHORIZED   SessionResponseCode = 7
	SessionResponseCode_FORBIDDEN      SessionResponseCode = 8
	SessionResponseCode_CONFLICT       SessionResponseCode = 9
	SessionResponseCode_INVALID        SessionResponseCode = 10
	SessionResponseCode_UNAVAILABLE    SessionResponseCode = 11
	SessionResponseCode_NOT_SUPPORTED  SessionResponseCode = 12
	SessionResponseCode_TIMEOUT        SessionResponseCode = 13
	SessionResponseCode_INTERNAL       SessionResponseCode = 14
)

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

var SessionResponseCode_value = map[string]int32{
	"OK":             0,
	"ERROR":          1,
	"NOT_LEADER":     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":       14,
}

func (x SessionResponseCode) String() string {
	return proto.EnumName(SessionResponseCode_name, int32(x))
}

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

type StateMachineSnapshot struct {
	Index     uint64            `protobuf:"varint,1,opt,name=index,proto3" 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"`
	Services  []ServiceSnapshot `protobuf:"bytes,4,rep,name=services,proto3" json:"services"`
}

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() uint64 {
	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
}

// Service snapshot
type ServiceSnapshot struct {
	ServiceID ServiceId `protobuf:"bytes,1,opt,name=service_id,json=serviceId,proto3" json:"service_id"`
	Index     uint64    `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	Data      []byte    `protobuf:"bytes,3,opt,name=data,proto3" json:"data,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{1}
}
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 ServiceId{}
}

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

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

// Service session
type SessionSnapshot struct {
	SessionID     uint64                    `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	Timeout       time.Duration             `protobuf:"bytes,2,opt,name=timeout,proto3,stdduration" json:"timeout"`
	Timestamp     time.Time                 `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
	LastRequestID uint64                    `protobuf:"varint,4,opt,name=last_request_id,json=lastRequestId,proto3" json:"last_request_id,omitempty"`
	Services      []*SessionServiceSnapshot `protobuf:"bytes,7,rep,name=services,proto3" json:"services,omitempty"`
	Commands      []*SessionCommandRequest  `protobuf:"bytes,8,rep,name=commands,proto3" json:"commands,omitempty"`
}

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{2}
}
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() uint64 {
	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) GetTimestamp() time.Time {
	if m != nil {
		return m.Timestamp
	}
	return time.Time{}
}

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

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

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

// Session service snapshot
type SessionServiceSnapshot struct {
	ServiceId ServiceId                `protobuf:"bytes,1,opt,name=service_id,json=serviceId,proto3" json:"service_id"`
	Streams   []*SessionStreamSnapshot `protobuf:"bytes,2,rep,name=streams,proto3" json:"streams,omitempty"`
}

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

var xxx_messageInfo_SessionServiceSnapshot proto.InternalMessageInfo

func (m *SessionServiceSnapshot) GetServiceId() ServiceId {
	if m != nil {
		return m.ServiceId
	}
	return ServiceId{}
}

func (m *SessionServiceSnapshot) GetStreams() []*SessionStreamSnapshot {
	if m != nil {
		return m.Streams
	}
	return nil
}

// Service session stream
type SessionStreamSnapshot struct {
	StreamID   uint64 `protobuf:"varint,1,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"`
	RequestID  uint64 `protobuf:"varint,2,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	Type       string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	ResponseID uint64 `protobuf:"varint,4,opt,name=response_id,json=responseId,proto3" json:"response_id,omitempty"`
	CompleteID uint64 `protobuf:"varint,5,opt,name=complete_id,json=completeId,proto3" json:"complete_id,omitempty"`
}

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

var xxx_messageInfo_SessionStreamSnapshot proto.InternalMessageInfo

func (m *SessionStreamSnapshot) GetStreamID() uint64 {
	if m != nil {
		return m.StreamID
	}
	return 0
}

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

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

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

func (m *SessionStreamSnapshot) GetCompleteID() uint64 {
	if m != nil {
		return m.CompleteID
	}
	return 0
}

type ServiceId struct {
	Type    string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Cluster string `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Name    string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}

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

var xxx_messageInfo_ServiceId proto.InternalMessageInfo

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

func (m *ServiceId) GetCluster() string {
	if m != nil {
		return m.Cluster
	}
	return ""
}

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

type StorageRequest struct {
	PartitionID uint32          `protobuf:"varint,1,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"`
	Request     *SessionRequest `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
}

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

var xxx_messageInfo_StorageRequest proto.InternalMessageInfo

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

func (m *StorageRequest) GetRequest() *SessionRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

type StorageResponse struct {
	PartitionID uint32           `protobuf:"varint,1,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"`
	Response    *SessionResponse `protobuf:"bytes,2,opt,name=response,proto3" json:"response,omitempty"`
}

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

var xxx_messageInfo_StorageResponse proto.InternalMessageInfo

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

func (m *StorageResponse) GetResponse() *SessionResponse {
	if m != nil {
		return m.Response
	}
	return nil
}

type StateMachineRequest struct {
	Timestamp time.Time       `protobuf:"bytes,1,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
	Request   *SessionRequest `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
}

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

var xxx_messageInfo_StateMachineRequest proto.InternalMessageInfo

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

func (m *StateMachineRequest) GetRequest() *SessionRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

type StateMachineResponse struct {
	Response *SessionResponse `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
}

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

var xxx_messageInfo_StateMachineResponse proto.InternalMessageInfo

func (m *StateMachineResponse) GetResponse() *SessionResponse {
	if m != nil {
		return m.Response
	}
	return nil
}

type SessionRequest struct {
	// Types that are valid to be assigned to Request:
	//	*SessionRequest_OpenSession
	//	*SessionRequest_KeepAlive
	//	*SessionRequest_CloseSession
	//	*SessionRequest_Command
	//	*SessionRequest_Query
	Request isSessionRequest_Request `protobuf_oneof:"request"`
}

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

var xxx_messageInfo_SessionRequest proto.InternalMessageInfo

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

type SessionRequest_OpenSession struct {
	OpenSession *OpenSessionRequest `protobuf:"bytes,1,opt,name=open_session,json=openSession,proto3,oneof" json:"open_session,omitempty"`
}
type SessionRequest_KeepAlive struct {
	KeepAlive *KeepAliveRequest `protobuf:"bytes,2,opt,name=keep_alive,json=keepAlive,proto3,oneof" json:"keep_alive,omitempty"`
}
type SessionRequest_CloseSession struct {
	CloseSession *CloseSessionRequest `protobuf:"bytes,3,opt,name=close_session,json=closeSession,proto3,oneof" json:"close_session,omitempty"`
}
type SessionRequest_Command struct {
	Command *SessionCommandRequest `protobuf:"bytes,4,opt,name=command,proto3,oneof" json:"command,omitempty"`
}
type SessionRequest_Query struct {
	Query *SessionQueryRequest `protobuf:"bytes,5,opt,name=query,proto3,oneof" json:"query,omitempty"`
}

func (*SessionRequest_OpenSession) isSessionRequest_Request()  {}
func (*SessionRequest_KeepAlive) isSessionRequest_Request()    {}
func (*SessionRequest_CloseSession) isSessionRequest_Request() {}
func (*SessionRequest_Command) isSessionRequest_Request()      {}
func (*SessionRequest_Query) isSessionRequest_Request()        {}

func (m *SessionRequest) GetRequest() isSessionRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

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

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

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

func (m *SessionRequest) GetCommand() *SessionCommandRequest {
	if x, ok := m.GetRequest().(*SessionRequest_Command); ok {
		return x.Command
	}
	return nil
}

func (m *SessionRequest) GetQuery() *SessionQueryRequest {
	if x, ok := m.GetRequest().(*SessionRequest_Query); ok {
		return x.Query
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SessionRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SessionRequest_OpenSession)(nil),
		(*SessionRequest_KeepAlive)(nil),
		(*SessionRequest_CloseSession)(nil),
		(*SessionRequest_Command)(nil),
		(*SessionRequest_Query)(nil),
	}
}

type SessionResponse struct {
	Type   SessionResponseType   `protobuf:"varint,1,opt,name=type,proto3,enum=atomix.service.SessionResponseType" json:"type,omitempty"`
	Status SessionResponseStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status"`
	// Types that are valid to be assigned to Response:
	//	*SessionResponse_OpenSession
	//	*SessionResponse_KeepAlive
	//	*SessionResponse_CloseSession
	//	*SessionResponse_Command
	//	*SessionResponse_Query
	Response isSessionResponse_Response `protobuf_oneof:"response"`
}

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

var xxx_messageInfo_SessionResponse proto.InternalMessageInfo

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

type SessionResponse_OpenSession struct {
	OpenSession *OpenSessionResponse `protobuf:"bytes,3,opt,name=open_session,json=openSession,proto3,oneof" json:"open_session,omitempty"`
}
type SessionResponse_KeepAlive struct {
	KeepAlive *KeepAliveResponse `protobuf:"bytes,4,opt,name=keep_alive,json=keepAlive,proto3,oneof" json:"keep_alive,omitempty"`
}
type SessionResponse_CloseSession struct {
	CloseSession *CloseSessionResponse `protobuf:"bytes,5,opt,name=close_session,json=closeSession,proto3,oneof" json:"close_session,omitempty"`
}
type SessionResponse_Command struct {
	Command *SessionCommandResponse `protobuf:"bytes,6,opt,name=command,proto3,oneof" json:"command,omitempty"`
}
type SessionResponse_Query struct {
	Query *SessionQueryResponse `protobuf:"bytes,7,opt,name=query,proto3,oneof" json:"query,omitempty"`
}

func (*SessionResponse_OpenSession) isSessionResponse_Response()  {}
func (*SessionResponse_KeepAlive) isSessionResponse_Response()    {}
func (*SessionResponse_CloseSession) isSessionResponse_Response() {}
func (*SessionResponse_Command) isSessionResponse_Response()      {}
func (*SessionResponse_Query) isSessionResponse_Response()        {}

func (m *SessionResponse) GetResponse() isSessionResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *SessionResponse) GetType() SessionResponseType {
	if m != nil {
		return m.Type
	}
	return SessionResponseType_RESPONSE
}

func (m *SessionResponse) GetStatus() SessionResponseStatus {
	if m != nil {
		return m.Status
	}
	return SessionResponseStatus{}
}

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

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

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

func (m *SessionResponse) GetCommand() *SessionCommandResponse {
	if x, ok := m.GetResponse().(*SessionResponse_Command); ok {
		return x.Command
	}
	return nil
}

func (m *SessionResponse) GetQuery() *SessionQueryResponse {
	if x, ok := m.GetResponse().(*SessionResponse_Query); ok {
		return x.Query
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SessionResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SessionResponse_OpenSession)(nil),
		(*SessionResponse_KeepAlive)(nil),
		(*SessionResponse_CloseSession)(nil),
		(*SessionResponse_Command)(nil),
		(*SessionResponse_Query)(nil),
	}
}

type OpenSessionRequest struct {
	ClientID string         `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	Timeout  *time.Duration `protobuf:"bytes,2,opt,name=timeout,proto3,stdduration" json:"timeout,omitempty"`
}

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) GetClientID() string {
	if m != nil {
		return m.ClientID
	}
	return ""
}

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

type OpenSessionResponse struct {
	SessionID uint64 `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3" 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() uint64 {
	if m != nil {
		return m.SessionID
	}
	return 0
}

type KeepAliveRequest struct {
	SessionID    uint64                 `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	AckRequestID uint64                 `protobuf:"varint,2,opt,name=ack_request_id,json=ackRequestId,proto3" json:"ack_request_id,omitempty"`
	Streams      []SessionStreamContext `protobuf:"bytes,3,rep,name=streams,proto3" json:"streams"`
}

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() uint64 {
	if m != nil {
		return m.SessionID
	}
	return 0
}

func (m *KeepAliveRequest) GetAckRequestID() uint64 {
	if m != nil {
		return m.AckRequestID
	}
	return 0
}

func (m *KeepAliveRequest) GetStreams() []SessionStreamContext {
	if m != nil {
		return m.Streams
	}
	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 uint64 `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3" 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() uint64 {
	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 {
	Context SessionCommandContext `protobuf:"bytes,1,opt,name=context,proto3" json:"context"`
	Command ServiceCommandRequest `protobuf:"bytes,2,opt,name=command,proto3" json:"command"`
}

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

func (m *SessionCommandRequest) GetContext() SessionCommandContext {
	if m != nil {
		return m.Context
	}
	return SessionCommandContext{}
}

func (m *SessionCommandRequest) GetCommand() ServiceCommandRequest {
	if m != nil {
		return m.Command
	}
	return ServiceCommandRequest{}
}

type SessionCommandResponse struct {
	Context  SessionResponseContext `protobuf:"bytes,1,opt,name=context,proto3" json:"context"`
	Response ServiceCommandResponse `protobuf:"bytes,2,opt,name=response,proto3" json:"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

func (m *SessionCommandResponse) GetContext() SessionResponseContext {
	if m != nil {
		return m.Context
	}
	return SessionResponseContext{}
}

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

type SessionQueryRequest struct {
	Context SessionQueryContext `protobuf:"bytes,1,opt,name=context,proto3" json:"context"`
	Query   ServiceQueryRequest `protobuf:"bytes,2,opt,name=query,proto3" json:"query"`
}

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{20}
}
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

func (m *SessionQueryRequest) GetContext() SessionQueryContext {
	if m != nil {
		return m.Context
	}
	return SessionQueryContext{}
}

func (m *SessionQueryRequest) GetQuery() ServiceQueryRequest {
	if m != nil {
		return m.Query
	}
	return ServiceQueryRequest{}
}

type SessionQueryResponse struct {
	Context  SessionResponseContext `protobuf:"bytes,1,opt,name=context,proto3" json:"context"`
	Response ServiceQueryResponse   `protobuf:"bytes,2,opt,name=response,proto3" json:"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{21}
}
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

func (m *SessionQueryResponse) GetContext() SessionResponseContext {
	if m != nil {
		return m.Context
	}
	return SessionResponseContext{}
}

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

type ServiceCommandRequest struct {
	Service ServiceId `protobuf:"bytes,1,opt,name=service,proto3" json:"service"`
	// Types that are valid to be assigned to Request:
	//	*ServiceCommandRequest_Operation
	//	*ServiceCommandRequest_Create
	//	*ServiceCommandRequest_Close
	//	*ServiceCommandRequest_Delete
	Request isServiceCommandRequest_Request `protobuf_oneof:"request"`
}

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{22}
}
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

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

type ServiceCommandRequest_Operation struct {
	Operation *ServiceOperationRequest `protobuf:"bytes,2,opt,name=operation,proto3,oneof" json:"operation,omitempty"`
}
type ServiceCommandRequest_Create struct {
	Create *ServiceCreateRequest `protobuf:"bytes,3,opt,name=create,proto3,oneof" json:"create,omitempty"`
}
type ServiceCommandRequest_Close struct {
	Close *ServiceCloseRequest `protobuf:"bytes,4,opt,name=close,proto3,oneof" json:"close,omitempty"`
}
type ServiceCommandRequest_Delete struct {
	Delete *ServiceDeleteRequest `protobuf:"bytes,5,opt,name=delete,proto3,oneof" json:"delete,omitempty"`
}

func (*ServiceCommandRequest_Operation) isServiceCommandRequest_Request() {}
func (*ServiceCommandRequest_Create) isServiceCommandRequest_Request()    {}
func (*ServiceCommandRequest_Close) isServiceCommandRequest_Request()     {}
func (*ServiceCommandRequest_Delete) isServiceCommandRequest_Request()    {}

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

func (m *ServiceCommandRequest) GetService() ServiceId {
	if m != nil {
		return m.Service
	}
	return ServiceId{}
}

func (m *ServiceCommandRequest) GetOperation() *ServiceOperationRequest {
	if x, ok := m.GetRequest().(*ServiceCommandRequest_Operation); ok {
		return x.Operation
	}
	return nil
}

func (m *ServiceCommandRequest) GetCreate() *ServiceCreateRequest {
	if x, ok := m.GetRequest().(*ServiceCommandRequest_Create); ok {
		return x.Create
	}
	return nil
}

func (m *ServiceCommandRequest) GetClose() *ServiceCloseRequest {
	if x, ok := m.GetRequest().(*ServiceCommandRequest_Close); ok {
		return x.Close
	}
	return nil
}

func (m *ServiceCommandRequest) GetDelete() *ServiceDeleteRequest {
	if x, ok := m.GetRequest().(*ServiceCommandRequest_Delete); ok {
		return x.Delete
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ServiceCommandRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ServiceCommandRequest_Operation)(nil),
		(*ServiceCommandRequest_Create)(nil),
		(*ServiceCommandRequest_Close)(nil),
		(*ServiceCommandRequest_Delete)(nil),
	}
}

type ServiceCommandResponse struct {
	// Types that are valid to be assigned to Response:
	//	*ServiceCommandResponse_Operation
	//	*ServiceCommandResponse_Create
	//	*ServiceCommandResponse_Close
	//	*ServiceCommandResponse_Delete
	Response isServiceCommandResponse_Response `protobuf_oneof:"response"`
}

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{23}
}
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

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

type ServiceCommandResponse_Operation struct {
	Operation *ServiceOperationResponse `protobuf:"bytes,1,opt,name=operation,proto3,oneof" json:"operation,omitempty"`
}
type ServiceCommandResponse_Create struct {
	Create *ServiceCreateResponse `protobuf:"bytes,2,opt,name=create,proto3,oneof" json:"create,omitempty"`
}
type ServiceCommandResponse_Close struct {
	Close *ServiceCloseResponse `protobuf:"bytes,3,opt,name=close,proto3,oneof" json:"close,omitempty"`
}
type ServiceCommandResponse_Delete struct {
	Delete *ServiceDeleteResponse `protobuf:"bytes,4,opt,name=delete,proto3,oneof" json:"delete,omitempty"`
}

func (*ServiceCommandResponse_Operation) isServiceCommandResponse_Response() {}
func (*ServiceCommandResponse_Create) isServiceCommandResponse_Response()    {}
func (*ServiceCommandResponse_Close) isServiceCommandResponse_Response()     {}
func (*ServiceCommandResponse_Delete) isServiceCommandResponse_Response()    {}

func (m *ServiceCommandResponse) GetResponse() isServiceCommandResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *ServiceCommandResponse) GetOperation() *ServiceOperationResponse {
	if x, ok := m.GetResponse().(*ServiceCommandResponse_Operation); ok {
		return x.Operation
	}
	return nil
}

func (m *ServiceCommandResponse) GetCreate() *ServiceCreateResponse {
	if x, ok := m.GetResponse().(*ServiceCommandResponse_Create); ok {
		return x.Create
	}
	return nil
}

func (m *ServiceCommandResponse) GetClose() *ServiceCloseResponse {
	if x, ok := m.GetResponse().(*ServiceCommandResponse_Close); ok {
		return x.Close
	}
	return nil
}

func (m *ServiceCommandResponse) GetDelete() *ServiceDeleteResponse {
	if x, ok := m.GetResponse().(*ServiceCommandResponse_Delete); ok {
		return x.Delete
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ServiceCommandResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ServiceCommandResponse_Operation)(nil),
		(*ServiceCommandResponse_Create)(nil),
		(*ServiceCommandResponse_Close)(nil),
		(*ServiceCommandResponse_Delete)(nil),
	}
}

type ServiceQueryRequest struct {
	Service *ServiceId `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	// Types that are valid to be assigned to Request:
	//	*ServiceQueryRequest_Operation
	//	*ServiceQueryRequest_Metadata
	Request isServiceQueryRequest_Request `protobuf_oneof:"request"`
}

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{24}
}
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

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

type ServiceQueryRequest_Operation struct {
	Operation *ServiceOperationRequest `protobuf:"bytes,2,opt,name=operation,proto3,oneof" json:"operation,omitempty"`
}
type ServiceQueryRequest_Metadata struct {
	Metadata *ServiceMetadataRequest `protobuf:"bytes,3,opt,name=metadata,proto3,oneof" json:"metadata,omitempty"`
}

func (*ServiceQueryRequest_Operation) isServiceQueryRequest_Request() {}
func (*ServiceQueryRequest_Metadata) isServiceQueryRequest_Request()  {}

func (m *ServiceQueryRequest) GetRequest() isServiceQueryRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *ServiceQueryRequest) GetService() *ServiceId {
	if m != nil {
		return m.Service
	}
	return nil
}

func (m *ServiceQueryRequest) GetOperation() *ServiceOperationRequest {
	if x, ok := m.GetRequest().(*ServiceQueryRequest_Operation); ok {
		return x.Operation
	}
	return nil
}

func (m *ServiceQueryRequest) GetMetadata() *ServiceMetadataRequest {
	if x, ok := m.GetRequest().(*ServiceQueryRequest_Metadata); ok {
		return x.Metadata
	}
	return nil
}

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

type ServiceQueryResponse struct {
	// Types that are valid to be assigned to Response:
	//	*ServiceQueryResponse_Operation
	//	*ServiceQueryResponse_Metadata
	Response isServiceQueryResponse_Response `protobuf_oneof:"response"`
}

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{25}
}
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

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

type ServiceQueryResponse_Operation struct {
	Operation *ServiceOperationResponse `protobuf:"bytes,2,opt,name=operation,proto3,oneof" json:"operation,omitempty"`
}
type ServiceQueryResponse_Metadata struct {
	Metadata *ServiceMetadataResponse `protobuf:"bytes,3,opt,name=metadata,proto3,oneof" json:"metadata,omitempty"`
}

func (*ServiceQueryResponse_Operation) isServiceQueryResponse_Response() {}
func (*ServiceQueryResponse_Metadata) isServiceQueryResponse_Response()  {}

func (m *ServiceQueryResponse) GetResponse() isServiceQueryResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *ServiceQueryResponse) GetOperation() *ServiceOperationResponse {
	if x, ok := m.GetResponse().(*ServiceQueryResponse_Operation); ok {
		return x.Operation
	}
	return nil
}

func (m *ServiceQueryResponse) GetMetadata() *ServiceMetadataResponse {
	if x, ok := m.GetResponse().(*ServiceQueryResponse_Metadata); ok {
		return x.Metadata
	}
	return nil
}

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

type ServiceOperationRequest struct {
	Method string `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
	Value  []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_ServiceOperationRequest proto.InternalMessageInfo

func (m *ServiceOperationRequest) GetMethod() string {
	if m != nil {
		return m.Method
	}
	return ""
}

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

type ServiceOperationResponse struct {
	Result []byte `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
}

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

var xxx_messageInfo_ServiceOperationResponse proto.InternalMessageInfo

func (m *ServiceOperationResponse) GetResult() []byte {
	if m != nil {
		return m.Result
	}
	return nil
}

type ServiceCreateRequest struct {
}

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

var xxx_messageInfo_ServiceCreateRequest proto.InternalMessageInfo

type ServiceCreateResponse struct {
}

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

var xxx_messageInfo_ServiceCreateResponse proto.InternalMessageInfo

type ServiceCloseRequest struct {
}

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

var xxx_messageInfo_ServiceCloseRequest proto.InternalMessageInfo

type ServiceCloseResponse struct {
}

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

var xxx_messageInfo_ServiceCloseResponse proto.InternalMessageInfo

type ServiceDeleteRequest struct {
}

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

var xxx_messageInfo_ServiceDeleteRequest proto.InternalMessageInfo

type ServiceDeleteResponse struct {
}

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

var xxx_messageInfo_ServiceDeleteResponse proto.InternalMessageInfo

type ServiceMetadataRequest struct {
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
}

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

var xxx_messageInfo_ServiceMetadataRequest proto.InternalMessageInfo

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

type ServiceMetadataResponse struct {
	Services []*ServiceId `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"`
}

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

var xxx_messageInfo_ServiceMetadataResponse proto.InternalMessageInfo

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

type SessionCommandContext struct {
	SessionID uint64 `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	RequestID uint64 `protobuf:"varint,2,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
}

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

var xxx_messageInfo_SessionCommandContext proto.InternalMessageInfo

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

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

type SessionQueryContext struct {
	SessionID     uint64 `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	LastRequestID uint64 `protobuf:"varint,2,opt,name=last_request_id,json=lastRequestId,proto3" json:"last_request_id,omitempty"`
	LastIndex     uint64 `protobuf:"varint,3,opt,name=last_index,json=lastIndex,proto3" json:"last_index,omitempty"`
	Sync          bool   `protobuf:"varint,4,opt,name=sync,proto3" json:"sync,omitempty"`
}

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

var xxx_messageInfo_SessionQueryContext proto.InternalMessageInfo

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

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

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

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

type SessionResponseContext struct {
	SessionID uint64 `protobuf:"varint,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	RequestID uint64 `protobuf:"varint,2,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	Index     uint64 `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
	Sequence  uint64 `protobuf:"varint,4,opt,name=sequence,proto3" json:"sequence,omitempty"`
}

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

var xxx_messageInfo_SessionResponseContext proto.InternalMessageInfo

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

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

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

func (m *SessionResponseContext) GetSequence() uint64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

type SessionStreamContext struct {
	RequestID     uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	AckResponseID uint64 `protobuf:"varint,2,opt,name=ack_response_id,json=ackResponseId,proto3" json:"ack_response_id,omitempty"`
}

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

var xxx_messageInfo_SessionStreamContext proto.InternalMessageInfo

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

func (m *SessionStreamContext) GetAckResponseID() uint64 {
	if m != nil {
		return m.AckResponseID
	}
	return 0
}

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

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

var xxx_messageInfo_SessionResponseStatus proto.InternalMessageInfo

func (m *SessionResponseStatus) GetCode() SessionResponseCode {
	if m != nil {
		return m.Code
	}
	return SessionResponseCode_OK
}

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

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

func init() {
	proto.RegisterEnum("atomix.service.SessionResponseType", SessionResponseType_name, SessionResponseType_value)
	proto.RegisterEnum("atomix.service.SessionResponseCode", SessionResponseCode_name, SessionResponseCode_value)
	proto.RegisterType((*StateMachineSnapshot)(nil), "atomix.service.StateMachineSnapshot")
	proto.RegisterType((*ServiceSnapshot)(nil), "atomix.service.ServiceSnapshot")
	proto.RegisterType((*SessionSnapshot)(nil), "atomix.service.SessionSnapshot")
	proto.RegisterType((*SessionServiceSnapshot)(nil), "atomix.service.SessionServiceSnapshot")
	proto.RegisterType((*SessionStreamSnapshot)(nil), "atomix.service.SessionStreamSnapshot")
	proto.RegisterType((*ServiceId)(nil), "atomix.service.ServiceId")
	proto.RegisterType((*StorageRequest)(nil), "atomix.service.StorageRequest")
	proto.RegisterType((*StorageResponse)(nil), "atomix.service.StorageResponse")
	proto.RegisterType((*StateMachineRequest)(nil), "atomix.service.StateMachineRequest")
	proto.RegisterType((*StateMachineResponse)(nil), "atomix.service.StateMachineResponse")
	proto.RegisterType((*SessionRequest)(nil), "atomix.service.SessionRequest")
	proto.RegisterType((*SessionResponse)(nil), "atomix.service.SessionResponse")
	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((*SessionQueryRequest)(nil), "atomix.service.SessionQueryRequest")
	proto.RegisterType((*SessionQueryResponse)(nil), "atomix.service.SessionQueryResponse")
	proto.RegisterType((*ServiceCommandRequest)(nil), "atomix.service.ServiceCommandRequest")
	proto.RegisterType((*ServiceCommandResponse)(nil), "atomix.service.ServiceCommandResponse")
	proto.RegisterType((*ServiceQueryRequest)(nil), "atomix.service.ServiceQueryRequest")
	proto.RegisterType((*ServiceQueryResponse)(nil), "atomix.service.ServiceQueryResponse")
	proto.RegisterType((*ServiceOperationRequest)(nil), "atomix.service.ServiceOperationRequest")
	proto.RegisterType((*ServiceOperationResponse)(nil), "atomix.service.ServiceOperationResponse")
	proto.RegisterType((*ServiceCreateRequest)(nil), "atomix.service.ServiceCreateRequest")
	proto.RegisterType((*ServiceCreateResponse)(nil), "atomix.service.ServiceCreateResponse")
	proto.RegisterType((*ServiceCloseRequest)(nil), "atomix.service.ServiceCloseRequest")
	proto.RegisterType((*ServiceCloseResponse)(nil), "atomix.service.ServiceCloseResponse")
	proto.RegisterType((*ServiceDeleteRequest)(nil), "atomix.service.ServiceDeleteRequest")
	proto.RegisterType((*ServiceDeleteResponse)(nil), "atomix.service.ServiceDeleteResponse")
	proto.RegisterType((*ServiceMetadataRequest)(nil), "atomix.service.ServiceMetadataRequest")
	proto.RegisterType((*ServiceMetadataResponse)(nil), "atomix.service.ServiceMetadataResponse")
	proto.RegisterType((*SessionCommandContext)(nil), "atomix.service.SessionCommandContext")
	proto.RegisterType((*SessionQueryContext)(nil), "atomix.service.SessionQueryContext")
	proto.RegisterType((*SessionResponseContext)(nil), "atomix.service.SessionResponseContext")
	proto.RegisterType((*SessionStreamContext)(nil), "atomix.service.SessionStreamContext")
	proto.RegisterType((*SessionResponseStatus)(nil), "atomix.service.SessionResponseStatus")
}

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

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

// StorageServiceClient is the client API for StorageService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type StorageServiceClient interface {
	Request(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error)
	Stream(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (StorageService_StreamClient, error)
}

type storageServiceClient struct {
	cc *grpc.ClientConn
}

func NewStorageServiceClient(cc *grpc.ClientConn) StorageServiceClient {
	return &storageServiceClient{cc}
}

func (c *storageServiceClient) Request(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error) {
	out := new(StorageResponse)
	err := c.cc.Invoke(ctx, "/atomix.service.StorageService/Request", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *storageServiceClient) Stream(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (StorageService_StreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StorageService_serviceDesc.Streams[0], "/atomix.service.StorageService/Stream", opts...)
	if err != nil {
		return nil, err
	}
	x := &storageServiceStreamClient{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 StorageService_StreamClient interface {
	Recv() (*StorageResponse, error)
	grpc.ClientStream
}

type storageServiceStreamClient struct {
	grpc.ClientStream
}

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

// StorageServiceServer is the server API for StorageService service.
type StorageServiceServer interface {
	Request(context.Context, *StorageRequest) (*StorageResponse, error)
	Stream(*StorageRequest, StorageService_StreamServer) error
}

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

func (*UnimplementedStorageServiceServer) Request(ctx context.Context, req *StorageRequest) (*StorageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Request not implemented")
}
func (*UnimplementedStorageServiceServer) Stream(req *StorageRequest, srv StorageService_StreamServer) error {
	return status.Errorf(codes.Unimplemented, "method Stream not implemented")
}

func RegisterStorageServiceServer(s *grpc.Server, srv StorageServiceServer) {
	s.RegisterService(&_StorageService_serviceDesc, srv)
}

func _StorageService_Request_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StorageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StorageServiceServer).Request(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/atomix.service.StorageService/Request",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StorageServiceServer).Request(ctx, req.(*StorageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StorageService_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StorageRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StorageServiceServer).Stream(m, &storageServiceStreamServer{stream})
}

type StorageService_StreamServer interface {
	Send(*StorageResponse) error
	grpc.ServerStream
}

type storageServiceStreamServer struct {
	grpc.ServerStream
}

func (x *storageServiceStreamServer) Send(m *StorageResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _StorageService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "atomix.service.StorageService",
	HandlerType: (*StorageServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Request",
			Handler:    _StorageService_Request_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Stream",
			Handler:       _StorageService_Stream_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 *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.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintService(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Index != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.ServiceID.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 *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
	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] = 0x42
		}
	}
	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] = 0x3a
		}
	}
	if m.LastRequestID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.LastRequestID))
		i--
		dAtA[i] = 0x20
	}
	n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
	if err3 != nil {
		return 0, err3
	}
	i -= n3
	i = encodeVarintService(dAtA, i, uint64(n3))
	i--
	dAtA[i] = 0x1a
	n4, err4 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Timeout, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Timeout):])
	if err4 != nil {
		return 0, err4
	}
	i -= n4
	i = encodeVarintService(dAtA, i, uint64(n4))
	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 *SessionServiceSnapshot) 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 *SessionServiceSnapshot) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionServiceSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Streams) > 0 {
		for iNdEx := len(m.Streams) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Streams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.ServiceId.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 *SessionStreamSnapshot) 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 *SessionStreamSnapshot) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionStreamSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CompleteID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.CompleteID))
		i--
		dAtA[i] = 0x28
	}
	if m.ResponseID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.ResponseID))
		i--
		dAtA[i] = 0x20
	}
	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] = 0x1a
	}
	if m.RequestID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.RequestID))
		i--
		dAtA[i] = 0x10
	}
	if m.StreamID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.StreamID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ServiceId) 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.Cluster) > 0 {
		i -= len(m.Cluster)
		copy(dAtA[i:], m.Cluster)
		i = encodeVarintService(dAtA, i, uint64(len(m.Cluster)))
		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 *StorageRequest) 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 *StorageRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StorageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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] = 0x12
	}
	if m.PartitionID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.PartitionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *StorageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != nil {
		{
			size, err := m.Response.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 *StateMachineRequest) 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 *StateMachineRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StateMachineRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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] = 0x12
	}
	n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
	if err9 != nil {
		return 0, err9
	}
	i -= n9
	i = encodeVarintService(dAtA, i, uint64(n9))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *StateMachineResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != nil {
		{
			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 *SessionRequest) 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 *SessionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionRequest) 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
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SessionRequest_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] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *SessionRequest_KeepAlive) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionRequest_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] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *SessionRequest_CloseSession) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionRequest_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] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *SessionRequest_Command) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionRequest_Command) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Command != nil {
		{
			size, err := m.Command.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 *SessionRequest_Query) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionRequest_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Query != nil {
		{
			size, err := m.Query.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 *SessionResponse) 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 *SessionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionResponse) 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
			}
		}
	}
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintService(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Type != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SessionResponse_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] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *SessionResponse_KeepAlive) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionResponse_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] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *SessionResponse_CloseSession) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionResponse_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] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *SessionResponse_Command) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *SessionResponse_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Query != nil {
		{
			size, err := m.Query.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	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
	if m.Timeout != nil {
		n22, err22 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Timeout, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Timeout):])
		if err22 != nil {
			return 0, err22
		}
		i -= n22
		i = encodeVarintService(dAtA, i, uint64(n22))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ClientID) > 0 {
		i -= len(m.ClientID)
		copy(dAtA[i:], m.ClientID)
		i = encodeVarintService(dAtA, i, uint64(len(m.ClientID)))
		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.Streams) > 0 {
		for iNdEx := len(m.Streams) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Streams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.AckRequestID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.AckRequestID))
		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
	{
		size, err := m.Command.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintService(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Context.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) 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
	{
		size, err := m.Response.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintService(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Context.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
	{
		size, err := m.Query.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintService(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Context.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 *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
	{
		size, err := m.Response.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintService(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Context.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 *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.Request != nil {
		{
			size := m.Request.Size()
			i -= size
			if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	{
		size, err := m.Service.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 *ServiceCommandRequest_Operation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ServiceCommandRequest_Create) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Create != nil {
		{
			size, err := m.Create.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 *ServiceCommandRequest_Close) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceCommandRequest_Close) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Close != nil {
		{
			size, err := m.Close.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 *ServiceCommandRequest_Delete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceCommandRequest_Delete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Delete != nil {
		{
			size, err := m.Delete.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 *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.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 *ServiceCommandResponse_Operation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceCommandResponse_Operation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	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] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *ServiceCommandResponse_Create) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceCommandResponse_Create) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Create != nil {
		{
			size, err := m.Create.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 *ServiceCommandResponse_Close) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceCommandResponse_Close) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Close != nil {
		{
			size, err := m.Close.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 *ServiceCommandResponse_Delete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceCommandResponse_Delete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Delete != nil {
		{
			size, err := m.Delete.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 *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.Request != nil {
		{
			size := m.Request.Size()
			i -= size
			if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Service != nil {
		{
			size, err := m.Service.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 *ServiceQueryRequest_Operation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ServiceQueryRequest_Metadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Metadata != nil {
		{
			size, err := m.Metadata.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 *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.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 *ServiceQueryResponse_Operation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ServiceQueryResponse_Metadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Metadata != nil {
		{
			size, err := m.Metadata.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 *ServiceOperationRequest) 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 *ServiceOperationRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceOperationRequest) 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 len(m.Method) > 0 {
		i -= len(m.Method)
		copy(dAtA[i:], m.Method)
		i = encodeVarintService(dAtA, i, uint64(len(m.Method)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *ServiceMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *ServiceMetadataResponse) 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 *ServiceMetadataResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceMetadataResponse) 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] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SessionCommandContext) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RequestID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.RequestID))
		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 *SessionQueryContext) 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 *SessionQueryContext) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionQueryContext) 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] = 0x20
	}
	if m.LastIndex != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.LastIndex))
		i--
		dAtA[i] = 0x18
	}
	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 *SessionResponseContext) 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 *SessionResponseContext) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SessionResponseContext) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sequence != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x20
	}
	if m.Index != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x18
	}
	if m.RequestID != 0 {
		i = encodeVarintService(dAtA, i, uint64(m.RequestID))
		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 *SessionStreamContext) 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 *SessionStreamContext) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *SessionResponseStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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] = 0x1a
	}
	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 *ServiceSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ServiceID.Size()
	n += 1 + l + sovService(uint64(l))
	if m.Index != 0 {
		n += 1 + sovService(uint64(m.Index))
	}
	l = len(m.Data)
	if l > 0 {
		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.Timestamp)
	n += 1 + l + sovService(uint64(l))
	if m.LastRequestID != 0 {
		n += 1 + sovService(uint64(m.LastRequestID))
	}
	if len(m.Services) > 0 {
		for _, e := range m.Services {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	if len(m.Commands) > 0 {
		for _, e := range m.Commands {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

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

func (m *SessionStreamSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StreamID != 0 {
		n += 1 + sovService(uint64(m.StreamID))
	}
	if m.RequestID != 0 {
		n += 1 + sovService(uint64(m.RequestID))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.ResponseID != 0 {
		n += 1 + sovService(uint64(m.ResponseID))
	}
	if m.CompleteID != 0 {
		n += 1 + sovService(uint64(m.CompleteID))
	}
	return n
}

func (m *ServiceId) 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.Cluster)
	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 *StorageRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PartitionID != 0 {
		n += 1 + sovService(uint64(m.PartitionID))
	}
	if m.Request != nil {
		l = m.Request.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

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

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

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

func (m *SessionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Request != nil {
		n += m.Request.Size()
	}
	return n
}

func (m *SessionRequest_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 *SessionRequest_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 *SessionRequest_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 *SessionRequest_Command) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Command != nil {
		l = m.Command.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionRequest_Query) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Query != nil {
		l = m.Query.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovService(uint64(m.Type))
	}
	l = m.Status.Size()
	n += 1 + l + sovService(uint64(l))
	if m.Response != nil {
		n += m.Response.Size()
	}
	return n
}

func (m *SessionResponse_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 *SessionResponse_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 *SessionResponse_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 *SessionResponse_Command) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Command != nil {
		l = m.Command.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *SessionResponse_Query) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Query != nil {
		l = m.Query.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 = len(m.ClientID)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.Timeout != nil {
		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.AckRequestID != 0 {
		n += 1 + sovService(uint64(m.AckRequestID))
	}
	if len(m.Streams) > 0 {
		for _, e := range m.Streams {
			l = e.Size()
			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
	l = m.Context.Size()
	n += 1 + l + sovService(uint64(l))
	l = m.Command.Size()
	n += 1 + l + sovService(uint64(l))
	return n
}

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

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

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

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

func (m *ServiceCommandRequest_Operation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Operation != nil {
		l = m.Operation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceCommandRequest_Create) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Create != nil {
		l = m.Create.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceCommandRequest_Close) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Close != nil {
		l = m.Close.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceCommandRequest_Delete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Delete != nil {
		l = m.Delete.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.Response != nil {
		n += m.Response.Size()
	}
	return n
}

func (m *ServiceCommandResponse_Operation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Operation != nil {
		l = m.Operation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceCommandResponse_Create) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Create != nil {
		l = m.Create.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceCommandResponse_Close) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Close != nil {
		l = m.Close.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceCommandResponse_Delete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Delete != nil {
		l = m.Delete.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.Service != nil {
		l = m.Service.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.Request != nil {
		n += m.Request.Size()
	}
	return n
}

func (m *ServiceQueryRequest_Operation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Operation != nil {
		l = m.Operation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceQueryRequest_Metadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.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.Response != nil {
		n += m.Response.Size()
	}
	return n
}

func (m *ServiceQueryResponse_Operation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Operation != nil {
		l = m.Operation.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceQueryResponse_Metadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}
func (m *ServiceOperationRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Method)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

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

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

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

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

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

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

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

func (m *ServiceMetadataRequest) 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))
	}
	return n
}

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

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

func (m *SessionQueryContext) 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))
	}
	if m.LastIndex != 0 {
		n += 1 + sovService(uint64(m.LastIndex))
	}
	if m.Sync {
		n += 2
	}
	return n
}

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

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

func (m *SessionResponseStatus) 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))
	}
	l = len(m.Leader)
	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 |= uint64(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 *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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", 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.ServiceID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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
		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 |= uint64(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 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 4:
			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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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, &SessionServiceSnapshot{})
			if err := m.Services[len(m.Services)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			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, &SessionCommandRequest{})
			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 *SessionServiceSnapshot) 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: SessionServiceSnapshot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionServiceSnapshot: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceId", 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.ServiceId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Streams", 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.Streams = append(m.Streams, &SessionStreamSnapshot{})
			if err := m.Streams[len(m.Streams)-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 *SessionStreamSnapshot) 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: SessionStreamSnapshot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionStreamSnapshot: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamID", wireType)
			}
			m.StreamID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StreamID |= uint64(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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompleteID", wireType)
			}
			m.CompleteID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompleteID |= uint64(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 *ServiceId) 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: ServiceId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceId: 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 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", 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.Cluster = 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 *StorageRequest) 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: StorageRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageRequest: 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 |= uint32(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 m.Request == nil {
				m.Request = &SessionRequest{}
			}
			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 *StorageResponse) 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: StorageResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageResponse: 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 |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 m.Response == nil {
				m.Response = &SessionResponse{}
			}
			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 *StateMachineRequest) 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: StateMachineRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StateMachineRequest: 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 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 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 = &SessionRequest{}
			}
			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 *StateMachineResponse) 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: StateMachineResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StateMachineResponse: 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 m.Response == nil {
				m.Response = &SessionResponse{}
			}
			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 *SessionRequest) 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: SessionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 = &SessionRequest_OpenSession{v}
			iNdEx = postIndex
		case 2:
			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 = &SessionRequest_KeepAlive{v}
			iNdEx = postIndex
		case 3:
			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 = &SessionRequest_CloseSession{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Command", 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 = &SessionRequest_Command{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", 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 = &SessionRequest_Query{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 *SessionResponse) 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: SessionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= SessionResponseType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 3:
			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 = &SessionResponse_OpenSession{v}
			iNdEx = postIndex
		case 4:
			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 = &SessionResponse_KeepAlive{v}
			iNdEx = postIndex
		case 5:
			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 = &SessionResponse_CloseSession{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Command", 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 = &SessionResponse_Command{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", 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 = &SessionResponse_Query{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 ClientID", 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.ClientID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		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 m.Timeout == nil {
				m.Timeout = new(time.Duration)
			}
			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 |= uint64(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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AckRequestID", wireType)
			}
			m.AckRequestID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AckRequestID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Streams", 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.Streams = append(m.Streams, SessionStreamContext{})
			if err := m.Streams[len(m.Streams)-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 *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 |= uint64(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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Context", 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.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Command", 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.Command.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 *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 Context", 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.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 *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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Context", 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.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", 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.Query.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 *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 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Context", 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.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 *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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", 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.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		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
			}
			v := &ServiceOperationRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &ServiceCommandRequest_Operation{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Create", 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 := &ServiceCreateRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &ServiceCommandRequest_Create{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Close", 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 := &ServiceCloseRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &ServiceCommandRequest_Close{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delete", 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 := &ServiceDeleteRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &ServiceCommandRequest_Delete{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 *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 != 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
			}
			v := &ServiceOperationResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ServiceCommandResponse_Operation{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Create", 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 := &ServiceCreateResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ServiceCommandResponse_Create{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Close", 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 := &ServiceCloseResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ServiceCommandResponse_Close{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delete", 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 := &ServiceDeleteResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ServiceCommandResponse_Delete{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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", 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.Service == nil {
				m.Service = &ServiceId{}
			}
			if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		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
			}
			v := &ServiceOperationRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &ServiceQueryRequest_Operation{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 := &ServiceMetadataRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &ServiceQueryRequest_Metadata{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 *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 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
			}
			v := &ServiceOperationResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ServiceQueryResponse_Operation{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 := &ServiceMetadataResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ServiceQueryResponse_Metadata{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 *ServiceOperationRequest) 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: ServiceOperationRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceOperationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Method", 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.Method = string(dAtA[iNdEx:postIndex])
			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 *ServiceOperationResponse) 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: ServiceOperationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceOperationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", 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.Result = append(m.Result[:0], dAtA[iNdEx:postIndex]...)
			if m.Result == nil {
				m.Result = []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 *ServiceCreateRequest) 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: ServiceCreateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceCreateRequest: 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 *ServiceCreateResponse) 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: ServiceCreateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceCreateResponse: 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 *ServiceCloseRequest) 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: ServiceCloseRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceCloseRequest: 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 *ServiceCloseResponse) 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: ServiceCloseResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceCloseResponse: 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 *ServiceDeleteRequest) 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: ServiceDeleteRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceDeleteRequest: 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 *ServiceDeleteResponse) 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: ServiceDeleteResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceDeleteResponse: 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 *ServiceMetadataRequest) 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: ServiceMetadataRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceMetadataRequest: 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 = 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 *ServiceMetadataResponse) 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: ServiceMetadataResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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, &ServiceId{})
			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 *SessionCommandContext) 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: SessionCommandContext: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionCommandContext: 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 |= uint64(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 |= uint64(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 *SessionQueryContext) 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: SessionQueryContext: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionQueryContext: 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 |= uint64(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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 *SessionResponseContext) 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: SessionResponseContext: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionResponseContext: 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 |= uint64(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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(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 *SessionStreamContext) 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: SessionStreamContext: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionStreamContext: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AckResponseID", wireType)
			}
			m.AckResponseID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AckResponseID |= uint64(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 *SessionResponseStatus) 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: SessionResponseStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionResponseStatus: 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 |= SessionResponseCode(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
		case 3:
			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
		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")
)