types.pb.go

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

package pb

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "github.com/vx-labs/mqtt-protocol/packet"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

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

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type StreamConfig struct {
	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	ShardIDs             []string `protobuf:"bytes,2,rep,name=ShardIDs,proto3" json:"ShardIDs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *StreamConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamConfig.Unmarshal(m, b)
}
func (m *StreamConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamConfig.Marshal(b, m, deterministic)
}
func (m *StreamConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamConfig.Merge(m, src)
}
func (m *StreamConfig) XXX_Size() int {
	return xxx_messageInfo_StreamConfig.Size(m)
}
func (m *StreamConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamConfig.DiscardUnknown(m)
}

var xxx_messageInfo_StreamConfig proto.InternalMessageInfo

func (m *StreamConfig) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *StreamConfig) GetShardIDs() []string {
	if m != nil {
		return m.ShardIDs
	}
	return nil
}

type StreamStatistics struct {
	ID                   string             `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	ShardStatistics      []*ShardStatistics `protobuf:"bytes,2,rep,name=ShardStatistics,proto3" json:"ShardStatistics,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

func (m *StreamStatistics) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamStatistics.Unmarshal(m, b)
}
func (m *StreamStatistics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamStatistics.Marshal(b, m, deterministic)
}
func (m *StreamStatistics) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamStatistics.Merge(m, src)
}
func (m *StreamStatistics) XXX_Size() int {
	return xxx_messageInfo_StreamStatistics.Size(m)
}
func (m *StreamStatistics) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamStatistics.DiscardUnknown(m)
}

var xxx_messageInfo_StreamStatistics proto.InternalMessageInfo

func (m *StreamStatistics) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *StreamStatistics) GetShardStatistics() []*ShardStatistics {
	if m != nil {
		return m.ShardStatistics
	}
	return nil
}

type ShardStatistics struct {
	StreamID             string   `protobuf:"bytes,1,opt,name=StreamID,proto3" json:"StreamID,omitempty"`
	ShardID              string   `protobuf:"bytes,2,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
	StoredBytes          int64    `protobuf:"varint,3,opt,name=StoredBytes,proto3" json:"StoredBytes,omitempty"`
	StoredRecordCount    int64    `protobuf:"varint,4,opt,name=StoredRecordCount,proto3" json:"StoredRecordCount,omitempty"`
	CurrentOffset        uint64   `protobuf:"varint,5,opt,name=CurrentOffset,proto3" json:"CurrentOffset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *ShardStatistics) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShardStatistics.Unmarshal(m, b)
}
func (m *ShardStatistics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShardStatistics.Marshal(b, m, deterministic)
}
func (m *ShardStatistics) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardStatistics.Merge(m, src)
}
func (m *ShardStatistics) XXX_Size() int {
	return xxx_messageInfo_ShardStatistics.Size(m)
}
func (m *ShardStatistics) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardStatistics.DiscardUnknown(m)
}

var xxx_messageInfo_ShardStatistics proto.InternalMessageInfo

func (m *ShardStatistics) GetStreamID() string {
	if m != nil {
		return m.StreamID
	}
	return ""
}

func (m *ShardStatistics) GetShardID() string {
	if m != nil {
		return m.ShardID
	}
	return ""
}

func (m *ShardStatistics) GetStoredBytes() int64 {
	if m != nil {
		return m.StoredBytes
	}
	return 0
}

func (m *ShardStatistics) GetStoredRecordCount() int64 {
	if m != nil {
		return m.StoredRecordCount
	}
	return 0
}

func (m *ShardStatistics) GetCurrentOffset() uint64 {
	if m != nil {
		return m.CurrentOffset
	}
	return 0
}

type StoredMessage struct {
	Offset               uint64   `protobuf:"varint,1,opt,name=Offset,proto3" json:"Offset,omitempty"`
	Payload              []byte   `protobuf:"bytes,2,opt,name=Payload,proto3" json:"Payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *StoredMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StoredMessage.Unmarshal(m, b)
}
func (m *StoredMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StoredMessage.Marshal(b, m, deterministic)
}
func (m *StoredMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StoredMessage.Merge(m, src)
}
func (m *StoredMessage) XXX_Size() int {
	return xxx_messageInfo_StoredMessage.Size(m)
}
func (m *StoredMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_StoredMessage.DiscardUnknown(m)
}

var xxx_messageInfo_StoredMessage proto.InternalMessageInfo

func (m *StoredMessage) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *StoredMessage) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

type MessageGetStreamInput struct {
	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *MessageGetStreamInput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageGetStreamInput.Unmarshal(m, b)
}
func (m *MessageGetStreamInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageGetStreamInput.Marshal(b, m, deterministic)
}
func (m *MessageGetStreamInput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageGetStreamInput.Merge(m, src)
}
func (m *MessageGetStreamInput) XXX_Size() int {
	return xxx_messageInfo_MessageGetStreamInput.Size(m)
}
func (m *MessageGetStreamInput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageGetStreamInput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageGetStreamInput proto.InternalMessageInfo

func (m *MessageGetStreamInput) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

type MessageGetStreamOutput struct {
	ID                   string        `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	Config               *StreamConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

func (m *MessageGetStreamOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageGetStreamOutput.Unmarshal(m, b)
}
func (m *MessageGetStreamOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageGetStreamOutput.Marshal(b, m, deterministic)
}
func (m *MessageGetStreamOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageGetStreamOutput.Merge(m, src)
}
func (m *MessageGetStreamOutput) XXX_Size() int {
	return xxx_messageInfo_MessageGetStreamOutput.Size(m)
}
func (m *MessageGetStreamOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageGetStreamOutput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageGetStreamOutput proto.InternalMessageInfo

func (m *MessageGetStreamOutput) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *MessageGetStreamOutput) GetConfig() *StreamConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

type MessageGetStreamStatisticsInput struct {
	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *MessageGetStreamStatisticsInput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageGetStreamStatisticsInput.Unmarshal(m, b)
}
func (m *MessageGetStreamStatisticsInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageGetStreamStatisticsInput.Marshal(b, m, deterministic)
}
func (m *MessageGetStreamStatisticsInput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageGetStreamStatisticsInput.Merge(m, src)
}
func (m *MessageGetStreamStatisticsInput) XXX_Size() int {
	return xxx_messageInfo_MessageGetStreamStatisticsInput.Size(m)
}
func (m *MessageGetStreamStatisticsInput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageGetStreamStatisticsInput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageGetStreamStatisticsInput proto.InternalMessageInfo

func (m *MessageGetStreamStatisticsInput) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

type MessageGetStreamStatisticsOutput struct {
	ID                   string            `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	Statistics           *StreamStatistics `protobuf:"bytes,2,opt,name=statistics,proto3" json:"statistics,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

func (m *MessageGetStreamStatisticsOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageGetStreamStatisticsOutput.Unmarshal(m, b)
}
func (m *MessageGetStreamStatisticsOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageGetStreamStatisticsOutput.Marshal(b, m, deterministic)
}
func (m *MessageGetStreamStatisticsOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageGetStreamStatisticsOutput.Merge(m, src)
}
func (m *MessageGetStreamStatisticsOutput) XXX_Size() int {
	return xxx_messageInfo_MessageGetStreamStatisticsOutput.Size(m)
}
func (m *MessageGetStreamStatisticsOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageGetStreamStatisticsOutput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageGetStreamStatisticsOutput proto.InternalMessageInfo

func (m *MessageGetStreamStatisticsOutput) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *MessageGetStreamStatisticsOutput) GetStatistics() *StreamStatistics {
	if m != nil {
		return m.Statistics
	}
	return nil
}

type MessageCreateStreamInput struct {
	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	ShardCount           int64    `protobuf:"varint,2,opt,name=ShardCount,proto3" json:"ShardCount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *MessageCreateStreamInput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageCreateStreamInput.Unmarshal(m, b)
}
func (m *MessageCreateStreamInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageCreateStreamInput.Marshal(b, m, deterministic)
}
func (m *MessageCreateStreamInput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageCreateStreamInput.Merge(m, src)
}
func (m *MessageCreateStreamInput) XXX_Size() int {
	return xxx_messageInfo_MessageCreateStreamInput.Size(m)
}
func (m *MessageCreateStreamInput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageCreateStreamInput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageCreateStreamInput proto.InternalMessageInfo

func (m *MessageCreateStreamInput) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *MessageCreateStreamInput) GetShardCount() int64 {
	if m != nil {
		return m.ShardCount
	}
	return 0
}

type MessageCreateStreamOutput struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessageCreateStreamOutput) Reset()         { *m = MessageCreateStreamOutput{} }
func (m *MessageCreateStreamOutput) String() string { return proto.CompactTextString(m) }
func (*MessageCreateStreamOutput) ProtoMessage()    {}
func (*MessageCreateStreamOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{9}
}

func (m *MessageCreateStreamOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageCreateStreamOutput.Unmarshal(m, b)
}
func (m *MessageCreateStreamOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageCreateStreamOutput.Marshal(b, m, deterministic)
}
func (m *MessageCreateStreamOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageCreateStreamOutput.Merge(m, src)
}
func (m *MessageCreateStreamOutput) XXX_Size() int {
	return xxx_messageInfo_MessageCreateStreamOutput.Size(m)
}
func (m *MessageCreateStreamOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageCreateStreamOutput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageCreateStreamOutput proto.InternalMessageInfo

type MessageDeleteStreamInput struct {
	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessageDeleteStreamInput) Reset()         { *m = MessageDeleteStreamInput{} }
func (m *MessageDeleteStreamInput) String() string { return proto.CompactTextString(m) }
func (*MessageDeleteStreamInput) ProtoMessage()    {}
func (*MessageDeleteStreamInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{10}
}

func (m *MessageDeleteStreamInput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageDeleteStreamInput.Unmarshal(m, b)
}
func (m *MessageDeleteStreamInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageDeleteStreamInput.Marshal(b, m, deterministic)
}
func (m *MessageDeleteStreamInput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageDeleteStreamInput.Merge(m, src)
}
func (m *MessageDeleteStreamInput) XXX_Size() int {
	return xxx_messageInfo_MessageDeleteStreamInput.Size(m)
}
func (m *MessageDeleteStreamInput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageDeleteStreamInput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageDeleteStreamInput proto.InternalMessageInfo

func (m *MessageDeleteStreamInput) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

type MessageDeleteStreamOutput struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessageDeleteStreamOutput) Reset()         { *m = MessageDeleteStreamOutput{} }
func (m *MessageDeleteStreamOutput) String() string { return proto.CompactTextString(m) }
func (*MessageDeleteStreamOutput) ProtoMessage()    {}
func (*MessageDeleteStreamOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{11}
}

func (m *MessageDeleteStreamOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageDeleteStreamOutput.Unmarshal(m, b)
}
func (m *MessageDeleteStreamOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageDeleteStreamOutput.Marshal(b, m, deterministic)
}
func (m *MessageDeleteStreamOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageDeleteStreamOutput.Merge(m, src)
}
func (m *MessageDeleteStreamOutput) XXX_Size() int {
	return xxx_messageInfo_MessageDeleteStreamOutput.Size(m)
}
func (m *MessageDeleteStreamOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageDeleteStreamOutput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageDeleteStreamOutput proto.InternalMessageInfo

type MessageListStreamInput struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessageListStreamInput) Reset()         { *m = MessageListStreamInput{} }
func (m *MessageListStreamInput) String() string { return proto.CompactTextString(m) }
func (*MessageListStreamInput) ProtoMessage()    {}
func (*MessageListStreamInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{12}
}

func (m *MessageListStreamInput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageListStreamInput.Unmarshal(m, b)
}
func (m *MessageListStreamInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageListStreamInput.Marshal(b, m, deterministic)
}
func (m *MessageListStreamInput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageListStreamInput.Merge(m, src)
}
func (m *MessageListStreamInput) XXX_Size() int {
	return xxx_messageInfo_MessageListStreamInput.Size(m)
}
func (m *MessageListStreamInput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageListStreamInput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageListStreamInput proto.InternalMessageInfo

type MessageListStreamOutput struct {
	Streams              []*StreamConfig `protobuf:"bytes,1,rep,name=Streams,proto3" json:"Streams,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *MessageListStreamOutput) Reset()         { *m = MessageListStreamOutput{} }
func (m *MessageListStreamOutput) String() string { return proto.CompactTextString(m) }
func (*MessageListStreamOutput) ProtoMessage()    {}
func (*MessageListStreamOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{13}
}

func (m *MessageListStreamOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageListStreamOutput.Unmarshal(m, b)
}
func (m *MessageListStreamOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageListStreamOutput.Marshal(b, m, deterministic)
}
func (m *MessageListStreamOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageListStreamOutput.Merge(m, src)
}
func (m *MessageListStreamOutput) XXX_Size() int {
	return xxx_messageInfo_MessageListStreamOutput.Size(m)
}
func (m *MessageListStreamOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageListStreamOutput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageListStreamOutput proto.InternalMessageInfo

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

type MessageGetMessagesInput struct {
	StreamID             string   `protobuf:"bytes,1,opt,name=StreamID,proto3" json:"StreamID,omitempty"`
	ShardID              string   `protobuf:"bytes,2,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
	Offset               uint64   `protobuf:"varint,3,opt,name=Offset,proto3" json:"Offset,omitempty"`
	MaxCount             uint64   `protobuf:"varint,4,opt,name=MaxCount,proto3" json:"MaxCount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessageGetMessagesInput) Reset()         { *m = MessageGetMessagesInput{} }
func (m *MessageGetMessagesInput) String() string { return proto.CompactTextString(m) }
func (*MessageGetMessagesInput) ProtoMessage()    {}
func (*MessageGetMessagesInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{14}
}

func (m *MessageGetMessagesInput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageGetMessagesInput.Unmarshal(m, b)
}
func (m *MessageGetMessagesInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageGetMessagesInput.Marshal(b, m, deterministic)
}
func (m *MessageGetMessagesInput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageGetMessagesInput.Merge(m, src)
}
func (m *MessageGetMessagesInput) XXX_Size() int {
	return xxx_messageInfo_MessageGetMessagesInput.Size(m)
}
func (m *MessageGetMessagesInput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageGetMessagesInput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageGetMessagesInput proto.InternalMessageInfo

func (m *MessageGetMessagesInput) GetStreamID() string {
	if m != nil {
		return m.StreamID
	}
	return ""
}

func (m *MessageGetMessagesInput) GetShardID() string {
	if m != nil {
		return m.ShardID
	}
	return ""
}

func (m *MessageGetMessagesInput) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *MessageGetMessagesInput) GetMaxCount() uint64 {
	if m != nil {
		return m.MaxCount
	}
	return 0
}

type MessageGetMessagesOutput struct {
	StreamID             string           `protobuf:"bytes,1,opt,name=StreamID,proto3" json:"StreamID,omitempty"`
	ShardID              string           `protobuf:"bytes,2,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
	NextOffset           uint64           `protobuf:"varint,3,opt,name=NextOffset,proto3" json:"NextOffset,omitempty"`
	Messages             []*StoredMessage `protobuf:"bytes,4,rep,name=Messages,proto3" json:"Messages,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *MessageGetMessagesOutput) Reset()         { *m = MessageGetMessagesOutput{} }
func (m *MessageGetMessagesOutput) String() string { return proto.CompactTextString(m) }
func (*MessageGetMessagesOutput) ProtoMessage()    {}
func (*MessageGetMessagesOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{15}
}

func (m *MessageGetMessagesOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageGetMessagesOutput.Unmarshal(m, b)
}
func (m *MessageGetMessagesOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageGetMessagesOutput.Marshal(b, m, deterministic)
}
func (m *MessageGetMessagesOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageGetMessagesOutput.Merge(m, src)
}
func (m *MessageGetMessagesOutput) XXX_Size() int {
	return xxx_messageInfo_MessageGetMessagesOutput.Size(m)
}
func (m *MessageGetMessagesOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageGetMessagesOutput.DiscardUnknown(m)
}

var xxx_messageInfo_MessageGetMessagesOutput proto.InternalMessageInfo

func (m *MessageGetMessagesOutput) GetStreamID() string {
	if m != nil {
		return m.StreamID
	}
	return ""
}

func (m *MessageGetMessagesOutput) GetShardID() string {
	if m != nil {
		return m.ShardID
	}
	return ""
}

func (m *MessageGetMessagesOutput) GetNextOffset() uint64 {
	if m != nil {
		return m.NextOffset
	}
	return 0
}

func (m *MessageGetMessagesOutput) GetMessages() []*StoredMessage {
	if m != nil {
		return m.Messages
	}
	return nil
}

type MessagePutMessageInput struct {
	StreamID             string   `protobuf:"bytes,1,opt,name=StreamID,proto3" json:"StreamID,omitempty"`
	ShardKey             string   `protobuf:"bytes,2,opt,name=ShardKey,proto3" json:"ShardKey,omitempty"`
	Payload              []byte   `protobuf:"bytes,3,opt,name=payload,proto3" json:"payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessagePutMessageInput) Reset()         { *m = MessagePutMessageInput{} }
func (m *MessagePutMessageInput) String() string { return proto.CompactTextString(m) }
func (*MessagePutMessageInput) ProtoMessage()    {}
func (*MessagePutMessageInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{16}
}

func (m *MessagePutMessageInput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePutMessageInput.Unmarshal(m, b)
}
func (m *MessagePutMessageInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePutMessageInput.Marshal(b, m, deterministic)
}
func (m *MessagePutMessageInput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePutMessageInput.Merge(m, src)
}
func (m *MessagePutMessageInput) XXX_Size() int {
	return xxx_messageInfo_MessagePutMessageInput.Size(m)
}
func (m *MessagePutMessageInput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePutMessageInput.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePutMessageInput proto.InternalMessageInfo

func (m *MessagePutMessageInput) GetStreamID() string {
	if m != nil {
		return m.StreamID
	}
	return ""
}

func (m *MessagePutMessageInput) GetShardKey() string {
	if m != nil {
		return m.ShardKey
	}
	return ""
}

func (m *MessagePutMessageInput) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

type MessagePutMessageOutput struct {
	StreamID             string   `protobuf:"bytes,1,opt,name=StreamID,proto3" json:"StreamID,omitempty"`
	ShardID              string   `protobuf:"bytes,2,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
	Offset               uint64   `protobuf:"varint,3,opt,name=Offset,proto3" json:"Offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessagePutMessageOutput) Reset()         { *m = MessagePutMessageOutput{} }
func (m *MessagePutMessageOutput) String() string { return proto.CompactTextString(m) }
func (*MessagePutMessageOutput) ProtoMessage()    {}
func (*MessagePutMessageOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{17}
}

func (m *MessagePutMessageOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePutMessageOutput.Unmarshal(m, b)
}
func (m *MessagePutMessageOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePutMessageOutput.Marshal(b, m, deterministic)
}
func (m *MessagePutMessageOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePutMessageOutput.Merge(m, src)
}
func (m *MessagePutMessageOutput) XXX_Size() int {
	return xxx_messageInfo_MessagePutMessageOutput.Size(m)
}
func (m *MessagePutMessageOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePutMessageOutput.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePutMessageOutput proto.InternalMessageInfo

func (m *MessagePutMessageOutput) GetStreamID() string {
	if m != nil {
		return m.StreamID
	}
	return ""
}

func (m *MessagePutMessageOutput) GetShardID() string {
	if m != nil {
		return m.ShardID
	}
	return ""
}

func (m *MessagePutMessageOutput) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

type MessagePutMessageBatchInput struct {
	Batches              []*MessagePutMessageInput `protobuf:"bytes,1,rep,name=Batches,proto3" json:"Batches,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *MessagePutMessageBatchInput) Reset()         { *m = MessagePutMessageBatchInput{} }
func (m *MessagePutMessageBatchInput) String() string { return proto.CompactTextString(m) }
func (*MessagePutMessageBatchInput) ProtoMessage()    {}
func (*MessagePutMessageBatchInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{18}
}

func (m *MessagePutMessageBatchInput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePutMessageBatchInput.Unmarshal(m, b)
}
func (m *MessagePutMessageBatchInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePutMessageBatchInput.Marshal(b, m, deterministic)
}
func (m *MessagePutMessageBatchInput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePutMessageBatchInput.Merge(m, src)
}
func (m *MessagePutMessageBatchInput) XXX_Size() int {
	return xxx_messageInfo_MessagePutMessageBatchInput.Size(m)
}
func (m *MessagePutMessageBatchInput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePutMessageBatchInput.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePutMessageBatchInput proto.InternalMessageInfo

func (m *MessagePutMessageBatchInput) GetBatches() []*MessagePutMessageInput {
	if m != nil {
		return m.Batches
	}
	return nil
}

type MessagePutMessageBatchOutput struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessagePutMessageBatchOutput) Reset()         { *m = MessagePutMessageBatchOutput{} }
func (m *MessagePutMessageBatchOutput) String() string { return proto.CompactTextString(m) }
func (*MessagePutMessageBatchOutput) ProtoMessage()    {}
func (*MessagePutMessageBatchOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{19}
}

func (m *MessagePutMessageBatchOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagePutMessageBatchOutput.Unmarshal(m, b)
}
func (m *MessagePutMessageBatchOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagePutMessageBatchOutput.Marshal(b, m, deterministic)
}
func (m *MessagePutMessageBatchOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagePutMessageBatchOutput.Merge(m, src)
}
func (m *MessagePutMessageBatchOutput) XXX_Size() int {
	return xxx_messageInfo_MessagePutMessageBatchOutput.Size(m)
}
func (m *MessagePutMessageBatchOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagePutMessageBatchOutput.DiscardUnknown(m)
}

var xxx_messageInfo_MessagePutMessageBatchOutput proto.InternalMessageInfo

type MessagesStateTransitionSet struct {
	Events               []*MessagesStateTransition `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *MessagesStateTransitionSet) Reset()         { *m = MessagesStateTransitionSet{} }
func (m *MessagesStateTransitionSet) String() string { return proto.CompactTextString(m) }
func (*MessagesStateTransitionSet) ProtoMessage()    {}
func (*MessagesStateTransitionSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{20}
}

func (m *MessagesStateTransitionSet) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagesStateTransitionSet.Unmarshal(m, b)
}
func (m *MessagesStateTransitionSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagesStateTransitionSet.Marshal(b, m, deterministic)
}
func (m *MessagesStateTransitionSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagesStateTransitionSet.Merge(m, src)
}
func (m *MessagesStateTransitionSet) XXX_Size() int {
	return xxx_messageInfo_MessagesStateTransitionSet.Size(m)
}
func (m *MessagesStateTransitionSet) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagesStateTransitionSet.DiscardUnknown(m)
}

var xxx_messageInfo_MessagesStateTransitionSet proto.InternalMessageInfo

func (m *MessagesStateTransitionSet) GetEvents() []*MessagesStateTransition {
	if m != nil {
		return m.Events
	}
	return nil
}

type MessagesStateTransition struct {
	// Types that are valid to be assigned to Event:
	//	*MessagesStateTransition_MessagePut
	//	*MessagesStateTransition_StreamCreated
	//	*MessagesStateTransition_StreamDeleted
	Event                isMessagesStateTransition_Event `protobuf_oneof:"Event"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

func (m *MessagesStateTransition) Reset()         { *m = MessagesStateTransition{} }
func (m *MessagesStateTransition) String() string { return proto.CompactTextString(m) }
func (*MessagesStateTransition) ProtoMessage()    {}
func (*MessagesStateTransition) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{21}
}

func (m *MessagesStateTransition) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagesStateTransition.Unmarshal(m, b)
}
func (m *MessagesStateTransition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagesStateTransition.Marshal(b, m, deterministic)
}
func (m *MessagesStateTransition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagesStateTransition.Merge(m, src)
}
func (m *MessagesStateTransition) XXX_Size() int {
	return xxx_messageInfo_MessagesStateTransition.Size(m)
}
func (m *MessagesStateTransition) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagesStateTransition.DiscardUnknown(m)
}

var xxx_messageInfo_MessagesStateTransition proto.InternalMessageInfo

type isMessagesStateTransition_Event interface {
	isMessagesStateTransition_Event()
}

type MessagesStateTransition_MessagePut struct {
	MessagePut *MessagesStateTransitionMessagePut `protobuf:"bytes,2,opt,name=MessagePut,proto3,oneof"`
}

type MessagesStateTransition_StreamCreated struct {
	StreamCreated *MessagesStateTransitionStreamCreated `protobuf:"bytes,3,opt,name=StreamCreated,proto3,oneof"`
}

type MessagesStateTransition_StreamDeleted struct {
	StreamDeleted *MessagesStateTransitionStreamDeleted `protobuf:"bytes,4,opt,name=StreamDeleted,proto3,oneof"`
}

func (*MessagesStateTransition_MessagePut) isMessagesStateTransition_Event() {}

func (*MessagesStateTransition_StreamCreated) isMessagesStateTransition_Event() {}

func (*MessagesStateTransition_StreamDeleted) isMessagesStateTransition_Event() {}

func (m *MessagesStateTransition) GetEvent() isMessagesStateTransition_Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *MessagesStateTransition) GetMessagePut() *MessagesStateTransitionMessagePut {
	if x, ok := m.GetEvent().(*MessagesStateTransition_MessagePut); ok {
		return x.MessagePut
	}
	return nil
}

func (m *MessagesStateTransition) GetStreamCreated() *MessagesStateTransitionStreamCreated {
	if x, ok := m.GetEvent().(*MessagesStateTransition_StreamCreated); ok {
		return x.StreamCreated
	}
	return nil
}

func (m *MessagesStateTransition) GetStreamDeleted() *MessagesStateTransitionStreamDeleted {
	if x, ok := m.GetEvent().(*MessagesStateTransition_StreamDeleted); ok {
		return x.StreamDeleted
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MessagesStateTransition) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MessagesStateTransition_MessagePut)(nil),
		(*MessagesStateTransition_StreamCreated)(nil),
		(*MessagesStateTransition_StreamDeleted)(nil),
	}
}

type MessagesStateTransitionStreamCreated struct {
	Config               *StreamConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *MessagesStateTransitionStreamCreated) Reset()         { *m = MessagesStateTransitionStreamCreated{} }
func (m *MessagesStateTransitionStreamCreated) String() string { return proto.CompactTextString(m) }
func (*MessagesStateTransitionStreamCreated) ProtoMessage()    {}
func (*MessagesStateTransitionStreamCreated) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{22}
}

func (m *MessagesStateTransitionStreamCreated) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagesStateTransitionStreamCreated.Unmarshal(m, b)
}
func (m *MessagesStateTransitionStreamCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagesStateTransitionStreamCreated.Marshal(b, m, deterministic)
}
func (m *MessagesStateTransitionStreamCreated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagesStateTransitionStreamCreated.Merge(m, src)
}
func (m *MessagesStateTransitionStreamCreated) XXX_Size() int {
	return xxx_messageInfo_MessagesStateTransitionStreamCreated.Size(m)
}
func (m *MessagesStateTransitionStreamCreated) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagesStateTransitionStreamCreated.DiscardUnknown(m)
}

var xxx_messageInfo_MessagesStateTransitionStreamCreated proto.InternalMessageInfo

func (m *MessagesStateTransitionStreamCreated) GetConfig() *StreamConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

type MessagesStateTransitionStreamDeleted struct {
	StreamID             string   `protobuf:"bytes,1,opt,name=StreamID,proto3" json:"StreamID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessagesStateTransitionStreamDeleted) Reset()         { *m = MessagesStateTransitionStreamDeleted{} }
func (m *MessagesStateTransitionStreamDeleted) String() string { return proto.CompactTextString(m) }
func (*MessagesStateTransitionStreamDeleted) ProtoMessage()    {}
func (*MessagesStateTransitionStreamDeleted) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{23}
}

func (m *MessagesStateTransitionStreamDeleted) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagesStateTransitionStreamDeleted.Unmarshal(m, b)
}
func (m *MessagesStateTransitionStreamDeleted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagesStateTransitionStreamDeleted.Marshal(b, m, deterministic)
}
func (m *MessagesStateTransitionStreamDeleted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagesStateTransitionStreamDeleted.Merge(m, src)
}
func (m *MessagesStateTransitionStreamDeleted) XXX_Size() int {
	return xxx_messageInfo_MessagesStateTransitionStreamDeleted.Size(m)
}
func (m *MessagesStateTransitionStreamDeleted) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagesStateTransitionStreamDeleted.DiscardUnknown(m)
}

var xxx_messageInfo_MessagesStateTransitionStreamDeleted proto.InternalMessageInfo

func (m *MessagesStateTransitionStreamDeleted) GetStreamID() string {
	if m != nil {
		return m.StreamID
	}
	return ""
}

type MessagesStateTransitionMessagePut struct {
	StreamID             string   `protobuf:"bytes,1,opt,name=StreamID,proto3" json:"StreamID,omitempty"`
	ShardID              string   `protobuf:"bytes,2,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
	Offset               uint64   `protobuf:"varint,3,opt,name=Offset,proto3" json:"Offset,omitempty"`
	Payload              []byte   `protobuf:"bytes,4,opt,name=Payload,proto3" json:"Payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessagesStateTransitionMessagePut) Reset()         { *m = MessagesStateTransitionMessagePut{} }
func (m *MessagesStateTransitionMessagePut) String() string { return proto.CompactTextString(m) }
func (*MessagesStateTransitionMessagePut) ProtoMessage()    {}
func (*MessagesStateTransitionMessagePut) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{24}
}

func (m *MessagesStateTransitionMessagePut) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessagesStateTransitionMessagePut.Unmarshal(m, b)
}
func (m *MessagesStateTransitionMessagePut) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessagesStateTransitionMessagePut.Marshal(b, m, deterministic)
}
func (m *MessagesStateTransitionMessagePut) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessagesStateTransitionMessagePut.Merge(m, src)
}
func (m *MessagesStateTransitionMessagePut) XXX_Size() int {
	return xxx_messageInfo_MessagesStateTransitionMessagePut.Size(m)
}
func (m *MessagesStateTransitionMessagePut) XXX_DiscardUnknown() {
	xxx_messageInfo_MessagesStateTransitionMessagePut.DiscardUnknown(m)
}

var xxx_messageInfo_MessagesStateTransitionMessagePut proto.InternalMessageInfo

func (m *MessagesStateTransitionMessagePut) GetStreamID() string {
	if m != nil {
		return m.StreamID
	}
	return ""
}

func (m *MessagesStateTransitionMessagePut) GetShardID() string {
	if m != nil {
		return m.ShardID
	}
	return ""
}

func (m *MessagesStateTransitionMessagePut) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *MessagesStateTransitionMessagePut) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func init() {
	proto.RegisterType((*StreamConfig)(nil), "pb.StreamConfig")
	proto.RegisterType((*StreamStatistics)(nil), "pb.StreamStatistics")
	proto.RegisterType((*ShardStatistics)(nil), "pb.ShardStatistics")
	proto.RegisterType((*StoredMessage)(nil), "pb.StoredMessage")
	proto.RegisterType((*MessageGetStreamInput)(nil), "pb.MessageGetStreamInput")
	proto.RegisterType((*MessageGetStreamOutput)(nil), "pb.MessageGetStreamOutput")
	proto.RegisterType((*MessageGetStreamStatisticsInput)(nil), "pb.MessageGetStreamStatisticsInput")
	proto.RegisterType((*MessageGetStreamStatisticsOutput)(nil), "pb.MessageGetStreamStatisticsOutput")
	proto.RegisterType((*MessageCreateStreamInput)(nil), "pb.MessageCreateStreamInput")
	proto.RegisterType((*MessageCreateStreamOutput)(nil), "pb.MessageCreateStreamOutput")
	proto.RegisterType((*MessageDeleteStreamInput)(nil), "pb.MessageDeleteStreamInput")
	proto.RegisterType((*MessageDeleteStreamOutput)(nil), "pb.MessageDeleteStreamOutput")
	proto.RegisterType((*MessageListStreamInput)(nil), "pb.MessageListStreamInput")
	proto.RegisterType((*MessageListStreamOutput)(nil), "pb.MessageListStreamOutput")
	proto.RegisterType((*MessageGetMessagesInput)(nil), "pb.MessageGetMessagesInput")
	proto.RegisterType((*MessageGetMessagesOutput)(nil), "pb.MessageGetMessagesOutput")
	proto.RegisterType((*MessagePutMessageInput)(nil), "pb.MessagePutMessageInput")
	proto.RegisterType((*MessagePutMessageOutput)(nil), "pb.MessagePutMessageOutput")
	proto.RegisterType((*MessagePutMessageBatchInput)(nil), "pb.MessagePutMessageBatchInput")
	proto.RegisterType((*MessagePutMessageBatchOutput)(nil), "pb.MessagePutMessageBatchOutput")
	proto.RegisterType((*MessagesStateTransitionSet)(nil), "pb.MessagesStateTransitionSet")
	proto.RegisterType((*MessagesStateTransition)(nil), "pb.MessagesStateTransition")
	proto.RegisterType((*MessagesStateTransitionStreamCreated)(nil), "pb.MessagesStateTransitionStreamCreated")
	proto.RegisterType((*MessagesStateTransitionStreamDeleted)(nil), "pb.MessagesStateTransitionStreamDeleted")
	proto.RegisterType((*MessagesStateTransitionMessagePut)(nil), "pb.MessagesStateTransitionMessagePut")
}

func init() { proto.RegisterFile("types.proto", fileDescriptor_d938547f84707355) }

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

// MessagesServiceClient is the client API for MessagesService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MessagesServiceClient interface {
	CreateStream(ctx context.Context, in *MessageCreateStreamInput, opts ...grpc.CallOption) (*MessageCreateStreamOutput, error)
	DeleteStream(ctx context.Context, in *MessageDeleteStreamInput, opts ...grpc.CallOption) (*MessageDeleteStreamOutput, error)
	ListStreams(ctx context.Context, in *MessageListStreamInput, opts ...grpc.CallOption) (*MessageListStreamOutput, error)
	GetStream(ctx context.Context, in *MessageGetStreamInput, opts ...grpc.CallOption) (*MessageGetStreamOutput, error)
	GetStreamStatistics(ctx context.Context, in *MessageGetStreamStatisticsInput, opts ...grpc.CallOption) (*MessageGetStreamStatisticsOutput, error)
	GetMessages(ctx context.Context, in *MessageGetMessagesInput, opts ...grpc.CallOption) (*MessageGetMessagesOutput, error)
	PutMessage(ctx context.Context, in *MessagePutMessageInput, opts ...grpc.CallOption) (*MessagePutMessageOutput, error)
	PutMessageBatch(ctx context.Context, in *MessagePutMessageBatchInput, opts ...grpc.CallOption) (*MessagePutMessageBatchOutput, error)
}

type messagesServiceClient struct {
	cc *grpc.ClientConn
}

func NewMessagesServiceClient(cc *grpc.ClientConn) MessagesServiceClient {
	return &messagesServiceClient{cc}
}

func (c *messagesServiceClient) CreateStream(ctx context.Context, in *MessageCreateStreamInput, opts ...grpc.CallOption) (*MessageCreateStreamOutput, error) {
	out := new(MessageCreateStreamOutput)
	err := c.cc.Invoke(ctx, "/pb.MessagesService/CreateStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messagesServiceClient) DeleteStream(ctx context.Context, in *MessageDeleteStreamInput, opts ...grpc.CallOption) (*MessageDeleteStreamOutput, error) {
	out := new(MessageDeleteStreamOutput)
	err := c.cc.Invoke(ctx, "/pb.MessagesService/DeleteStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messagesServiceClient) ListStreams(ctx context.Context, in *MessageListStreamInput, opts ...grpc.CallOption) (*MessageListStreamOutput, error) {
	out := new(MessageListStreamOutput)
	err := c.cc.Invoke(ctx, "/pb.MessagesService/ListStreams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messagesServiceClient) GetStream(ctx context.Context, in *MessageGetStreamInput, opts ...grpc.CallOption) (*MessageGetStreamOutput, error) {
	out := new(MessageGetStreamOutput)
	err := c.cc.Invoke(ctx, "/pb.MessagesService/GetStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messagesServiceClient) GetStreamStatistics(ctx context.Context, in *MessageGetStreamStatisticsInput, opts ...grpc.CallOption) (*MessageGetStreamStatisticsOutput, error) {
	out := new(MessageGetStreamStatisticsOutput)
	err := c.cc.Invoke(ctx, "/pb.MessagesService/GetStreamStatistics", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messagesServiceClient) GetMessages(ctx context.Context, in *MessageGetMessagesInput, opts ...grpc.CallOption) (*MessageGetMessagesOutput, error) {
	out := new(MessageGetMessagesOutput)
	err := c.cc.Invoke(ctx, "/pb.MessagesService/GetMessages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messagesServiceClient) PutMessage(ctx context.Context, in *MessagePutMessageInput, opts ...grpc.CallOption) (*MessagePutMessageOutput, error) {
	out := new(MessagePutMessageOutput)
	err := c.cc.Invoke(ctx, "/pb.MessagesService/PutMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messagesServiceClient) PutMessageBatch(ctx context.Context, in *MessagePutMessageBatchInput, opts ...grpc.CallOption) (*MessagePutMessageBatchOutput, error) {
	out := new(MessagePutMessageBatchOutput)
	err := c.cc.Invoke(ctx, "/pb.MessagesService/PutMessageBatch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MessagesServiceServer is the server API for MessagesService service.
type MessagesServiceServer interface {
	CreateStream(context.Context, *MessageCreateStreamInput) (*MessageCreateStreamOutput, error)
	DeleteStream(context.Context, *MessageDeleteStreamInput) (*MessageDeleteStreamOutput, error)
	ListStreams(context.Context, *MessageListStreamInput) (*MessageListStreamOutput, error)
	GetStream(context.Context, *MessageGetStreamInput) (*MessageGetStreamOutput, error)
	GetStreamStatistics(context.Context, *MessageGetStreamStatisticsInput) (*MessageGetStreamStatisticsOutput, error)
	GetMessages(context.Context, *MessageGetMessagesInput) (*MessageGetMessagesOutput, error)
	PutMessage(context.Context, *MessagePutMessageInput) (*MessagePutMessageOutput, error)
	PutMessageBatch(context.Context, *MessagePutMessageBatchInput) (*MessagePutMessageBatchOutput, error)
}

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

func (*UnimplementedMessagesServiceServer) CreateStream(ctx context.Context, req *MessageCreateStreamInput) (*MessageCreateStreamOutput, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateStream not implemented")
}
func (*UnimplementedMessagesServiceServer) DeleteStream(ctx context.Context, req *MessageDeleteStreamInput) (*MessageDeleteStreamOutput, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteStream not implemented")
}
func (*UnimplementedMessagesServiceServer) ListStreams(ctx context.Context, req *MessageListStreamInput) (*MessageListStreamOutput, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListStreams not implemented")
}
func (*UnimplementedMessagesServiceServer) GetStream(ctx context.Context, req *MessageGetStreamInput) (*MessageGetStreamOutput, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStream not implemented")
}
func (*UnimplementedMessagesServiceServer) GetStreamStatistics(ctx context.Context, req *MessageGetStreamStatisticsInput) (*MessageGetStreamStatisticsOutput, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStreamStatistics not implemented")
}
func (*UnimplementedMessagesServiceServer) GetMessages(ctx context.Context, req *MessageGetMessagesInput) (*MessageGetMessagesOutput, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMessages not implemented")
}
func (*UnimplementedMessagesServiceServer) PutMessage(ctx context.Context, req *MessagePutMessageInput) (*MessagePutMessageOutput, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PutMessage not implemented")
}
func (*UnimplementedMessagesServiceServer) PutMessageBatch(ctx context.Context, req *MessagePutMessageBatchInput) (*MessagePutMessageBatchOutput, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PutMessageBatch not implemented")
}

func RegisterMessagesServiceServer(s *grpc.Server, srv MessagesServiceServer) {
	s.RegisterService(&_MessagesService_serviceDesc, srv)
}

func _MessagesService_CreateStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessageCreateStreamInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessagesServiceServer).CreateStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.MessagesService/CreateStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessagesServiceServer).CreateStream(ctx, req.(*MessageCreateStreamInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessagesService_DeleteStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessageDeleteStreamInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessagesServiceServer).DeleteStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.MessagesService/DeleteStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessagesServiceServer).DeleteStream(ctx, req.(*MessageDeleteStreamInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessagesService_ListStreams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessageListStreamInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessagesServiceServer).ListStreams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.MessagesService/ListStreams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessagesServiceServer).ListStreams(ctx, req.(*MessageListStreamInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessagesService_GetStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessageGetStreamInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessagesServiceServer).GetStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.MessagesService/GetStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessagesServiceServer).GetStream(ctx, req.(*MessageGetStreamInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessagesService_GetStreamStatistics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessageGetStreamStatisticsInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessagesServiceServer).GetStreamStatistics(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.MessagesService/GetStreamStatistics",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessagesServiceServer).GetStreamStatistics(ctx, req.(*MessageGetStreamStatisticsInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessagesService_GetMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessageGetMessagesInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessagesServiceServer).GetMessages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.MessagesService/GetMessages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessagesServiceServer).GetMessages(ctx, req.(*MessageGetMessagesInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessagesService_PutMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessagePutMessageInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessagesServiceServer).PutMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.MessagesService/PutMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessagesServiceServer).PutMessage(ctx, req.(*MessagePutMessageInput))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessagesService_PutMessageBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MessagePutMessageBatchInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessagesServiceServer).PutMessageBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.MessagesService/PutMessageBatch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessagesServiceServer).PutMessageBatch(ctx, req.(*MessagePutMessageBatchInput))
	}
	return interceptor(ctx, in, info, handler)
}

var _MessagesService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.MessagesService",
	HandlerType: (*MessagesServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateStream",
			Handler:    _MessagesService_CreateStream_Handler,
		},
		{
			MethodName: "DeleteStream",
			Handler:    _MessagesService_DeleteStream_Handler,
		},
		{
			MethodName: "ListStreams",
			Handler:    _MessagesService_ListStreams_Handler,
		},
		{
			MethodName: "GetStream",
			Handler:    _MessagesService_GetStream_Handler,
		},
		{
			MethodName: "GetStreamStatistics",
			Handler:    _MessagesService_GetStreamStatistics_Handler,
		},
		{
			MethodName: "GetMessages",
			Handler:    _MessagesService_GetMessages_Handler,
		},
		{
			MethodName: "PutMessage",
			Handler:    _MessagesService_PutMessage_Handler,
		},
		{
			MethodName: "PutMessageBatch",
			Handler:    _MessagesService_PutMessageBatch_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "types.proto",
}