corteza/sam/chat/chat.pb.go

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

package chat

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

type StreamRequest struct {
	// Types that are valid to be assigned to Event:
	//	*StreamRequest_Login_
	//	*StreamRequest_ChannelJoin
	//	*StreamRequest_ChannelPart
	//	*StreamRequest_Message_
	//	*StreamRequest_Quit_
	Event                isStreamRequest_Event `protobuf_oneof:"event"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *StreamRequest) Reset()         { *m = StreamRequest{} }
func (m *StreamRequest) String() string { return proto.CompactTextString(m) }
func (*StreamRequest) ProtoMessage()    {}
func (*StreamRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{0}
}
func (m *StreamRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamRequest.Unmarshal(m, b)
}
func (m *StreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamRequest.Marshal(b, m, deterministic)
}
func (dst *StreamRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamRequest.Merge(dst, src)
}
func (m *StreamRequest) XXX_Size() int {
	return xxx_messageInfo_StreamRequest.Size(m)
}
func (m *StreamRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StreamRequest proto.InternalMessageInfo

type isStreamRequest_Event interface {
	isStreamRequest_Event()
}

type StreamRequest_Login_ struct {
	Login *StreamRequest_Login `protobuf:"bytes,1,opt,name=login,oneof"`
}
type StreamRequest_ChannelJoin struct {
	ChannelJoin *StreamRequest_Join `protobuf:"bytes,2,opt,name=channel_join,json=channelJoin,oneof"`
}
type StreamRequest_ChannelPart struct {
	ChannelPart *StreamRequest_Part `protobuf:"bytes,3,opt,name=channel_part,json=channelPart,oneof"`
}
type StreamRequest_Message_ struct {
	Message *StreamRequest_Message `protobuf:"bytes,4,opt,name=message,oneof"`
}
type StreamRequest_Quit_ struct {
	Quit *StreamRequest_Quit `protobuf:"bytes,5,opt,name=quit,oneof"`
}

func (*StreamRequest_Login_) isStreamRequest_Event()      {}
func (*StreamRequest_ChannelJoin) isStreamRequest_Event() {}
func (*StreamRequest_ChannelPart) isStreamRequest_Event() {}
func (*StreamRequest_Message_) isStreamRequest_Event()    {}
func (*StreamRequest_Quit_) isStreamRequest_Event()       {}

func (m *StreamRequest) GetEvent() isStreamRequest_Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *StreamRequest) GetLogin() *StreamRequest_Login {
	if x, ok := m.GetEvent().(*StreamRequest_Login_); ok {
		return x.Login
	}
	return nil
}

func (m *StreamRequest) GetChannelJoin() *StreamRequest_Join {
	if x, ok := m.GetEvent().(*StreamRequest_ChannelJoin); ok {
		return x.ChannelJoin
	}
	return nil
}

func (m *StreamRequest) GetChannelPart() *StreamRequest_Part {
	if x, ok := m.GetEvent().(*StreamRequest_ChannelPart); ok {
		return x.ChannelPart
	}
	return nil
}

func (m *StreamRequest) GetMessage() *StreamRequest_Message {
	if x, ok := m.GetEvent().(*StreamRequest_Message_); ok {
		return x.Message
	}
	return nil
}

func (m *StreamRequest) GetQuit() *StreamRequest_Quit {
	if x, ok := m.GetEvent().(*StreamRequest_Quit_); ok {
		return x.Quit
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*StreamRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _StreamRequest_OneofMarshaler, _StreamRequest_OneofUnmarshaler, _StreamRequest_OneofSizer, []interface{}{
		(*StreamRequest_Login_)(nil),
		(*StreamRequest_ChannelJoin)(nil),
		(*StreamRequest_ChannelPart)(nil),
		(*StreamRequest_Message_)(nil),
		(*StreamRequest_Quit_)(nil),
	}
}

func _StreamRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*StreamRequest)
	// event
	switch x := m.Event.(type) {
	case *StreamRequest_Login_:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Login); err != nil {
			return err
		}
	case *StreamRequest_ChannelJoin:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelJoin); err != nil {
			return err
		}
	case *StreamRequest_ChannelPart:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelPart); err != nil {
			return err
		}
	case *StreamRequest_Message_:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Message); err != nil {
			return err
		}
	case *StreamRequest_Quit_:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Quit); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("StreamRequest.Event has unexpected type %T", x)
	}
	return nil
}

func _StreamRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*StreamRequest)
	switch tag {
	case 1: // event.login
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamRequest_Login)
		err := b.DecodeMessage(msg)
		m.Event = &StreamRequest_Login_{msg}
		return true, err
	case 2: // event.channel_join
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamRequest_Join)
		err := b.DecodeMessage(msg)
		m.Event = &StreamRequest_ChannelJoin{msg}
		return true, err
	case 3: // event.channel_part
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamRequest_Part)
		err := b.DecodeMessage(msg)
		m.Event = &StreamRequest_ChannelPart{msg}
		return true, err
	case 4: // event.message
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamRequest_Message)
		err := b.DecodeMessage(msg)
		m.Event = &StreamRequest_Message_{msg}
		return true, err
	case 5: // event.quit
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamRequest_Quit)
		err := b.DecodeMessage(msg)
		m.Event = &StreamRequest_Quit_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _StreamRequest_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*StreamRequest)
	// event
	switch x := m.Event.(type) {
	case *StreamRequest_Login_:
		s := proto.Size(x.Login)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamRequest_ChannelJoin:
		s := proto.Size(x.ChannelJoin)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamRequest_ChannelPart:
		s := proto.Size(x.ChannelPart)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamRequest_Message_:
		s := proto.Size(x.Message)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamRequest_Quit_:
		s := proto.Size(x.Quit)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

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

func (m *StreamRequest_Login) Reset()         { *m = StreamRequest_Login{} }
func (m *StreamRequest_Login) String() string { return proto.CompactTextString(m) }
func (*StreamRequest_Login) ProtoMessage()    {}
func (*StreamRequest_Login) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{0, 0}
}
func (m *StreamRequest_Login) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamRequest_Login.Unmarshal(m, b)
}
func (m *StreamRequest_Login) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamRequest_Login.Marshal(b, m, deterministic)
}
func (dst *StreamRequest_Login) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamRequest_Login.Merge(dst, src)
}
func (m *StreamRequest_Login) XXX_Size() int {
	return xxx_messageInfo_StreamRequest_Login.Size(m)
}
func (m *StreamRequest_Login) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamRequest_Login.DiscardUnknown(m)
}

var xxx_messageInfo_StreamRequest_Login proto.InternalMessageInfo

func (m *StreamRequest_Login) GetSession() string {
	if m != nil {
		return m.Session
	}
	return ""
}

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

func (m *StreamRequest_Join) Reset()         { *m = StreamRequest_Join{} }
func (m *StreamRequest_Join) String() string { return proto.CompactTextString(m) }
func (*StreamRequest_Join) ProtoMessage()    {}
func (*StreamRequest_Join) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{0, 1}
}
func (m *StreamRequest_Join) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamRequest_Join.Unmarshal(m, b)
}
func (m *StreamRequest_Join) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamRequest_Join.Marshal(b, m, deterministic)
}
func (dst *StreamRequest_Join) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamRequest_Join.Merge(dst, src)
}
func (m *StreamRequest_Join) XXX_Size() int {
	return xxx_messageInfo_StreamRequest_Join.Size(m)
}
func (m *StreamRequest_Join) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamRequest_Join.DiscardUnknown(m)
}

var xxx_messageInfo_StreamRequest_Join proto.InternalMessageInfo

func (m *StreamRequest_Join) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

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

func (m *StreamRequest_Part) Reset()         { *m = StreamRequest_Part{} }
func (m *StreamRequest_Part) String() string { return proto.CompactTextString(m) }
func (*StreamRequest_Part) ProtoMessage()    {}
func (*StreamRequest_Part) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{0, 2}
}
func (m *StreamRequest_Part) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamRequest_Part.Unmarshal(m, b)
}
func (m *StreamRequest_Part) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamRequest_Part.Marshal(b, m, deterministic)
}
func (dst *StreamRequest_Part) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamRequest_Part.Merge(dst, src)
}
func (m *StreamRequest_Part) XXX_Size() int {
	return xxx_messageInfo_StreamRequest_Part.Size(m)
}
func (m *StreamRequest_Part) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamRequest_Part.DiscardUnknown(m)
}

var xxx_messageInfo_StreamRequest_Part proto.InternalMessageInfo

func (m *StreamRequest_Part) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

type StreamRequest_Message struct {
	To                   string   `protobuf:"bytes,1,opt,name=to" json:"to,omitempty"`
	Message              string   `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamRequest_Message) Reset()         { *m = StreamRequest_Message{} }
func (m *StreamRequest_Message) String() string { return proto.CompactTextString(m) }
func (*StreamRequest_Message) ProtoMessage()    {}
func (*StreamRequest_Message) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{0, 3}
}
func (m *StreamRequest_Message) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamRequest_Message.Unmarshal(m, b)
}
func (m *StreamRequest_Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamRequest_Message.Marshal(b, m, deterministic)
}
func (dst *StreamRequest_Message) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamRequest_Message.Merge(dst, src)
}
func (m *StreamRequest_Message) XXX_Size() int {
	return xxx_messageInfo_StreamRequest_Message.Size(m)
}
func (m *StreamRequest_Message) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamRequest_Message.DiscardUnknown(m)
}

var xxx_messageInfo_StreamRequest_Message proto.InternalMessageInfo

func (m *StreamRequest_Message) GetTo() string {
	if m != nil {
		return m.To
	}
	return ""
}

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

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

func (m *StreamRequest_Quit) Reset()         { *m = StreamRequest_Quit{} }
func (m *StreamRequest_Quit) String() string { return proto.CompactTextString(m) }
func (*StreamRequest_Quit) ProtoMessage()    {}
func (*StreamRequest_Quit) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{0, 4}
}
func (m *StreamRequest_Quit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamRequest_Quit.Unmarshal(m, b)
}
func (m *StreamRequest_Quit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamRequest_Quit.Marshal(b, m, deterministic)
}
func (dst *StreamRequest_Quit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamRequest_Quit.Merge(dst, src)
}
func (m *StreamRequest_Quit) XXX_Size() int {
	return xxx_messageInfo_StreamRequest_Quit.Size(m)
}
func (m *StreamRequest_Quit) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamRequest_Quit.DiscardUnknown(m)
}

var xxx_messageInfo_StreamRequest_Quit proto.InternalMessageInfo

type StreamResponse struct {
	Id        uint64               `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	Timestamp *timestamp.Timestamp `protobuf:"bytes,2,opt,name=timestamp" json:"timestamp,omitempty"`
	// Types that are valid to be assigned to Event:
	//	*StreamResponse_Error_
	//	*StreamResponse_Login_
	//	*StreamResponse_ChannelJoin
	//	*StreamResponse_ChannelNames
	//	*StreamResponse_ChannelPart
	//	*StreamResponse_UserNames
	//	*StreamResponse_Message_
	//	*StreamResponse_Shutdown_
	Event                isStreamResponse_Event `protobuf_oneof:"event"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *StreamResponse) Reset()         { *m = StreamResponse{} }
func (m *StreamResponse) String() string { return proto.CompactTextString(m) }
func (*StreamResponse) ProtoMessage()    {}
func (*StreamResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1}
}
func (m *StreamResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse.Unmarshal(m, b)
}
func (m *StreamResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse.Marshal(b, m, deterministic)
}
func (dst *StreamResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse.Merge(dst, src)
}
func (m *StreamResponse) XXX_Size() int {
	return xxx_messageInfo_StreamResponse.Size(m)
}
func (m *StreamResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse proto.InternalMessageInfo

type isStreamResponse_Event interface {
	isStreamResponse_Event()
}

type StreamResponse_Error_ struct {
	Error *StreamResponse_Error `protobuf:"bytes,3,opt,name=error,oneof"`
}
type StreamResponse_Login_ struct {
	Login *StreamResponse_Login `protobuf:"bytes,4,opt,name=login,oneof"`
}
type StreamResponse_ChannelJoin struct {
	ChannelJoin *StreamResponse_Join `protobuf:"bytes,5,opt,name=channel_join,json=channelJoin,oneof"`
}
type StreamResponse_ChannelNames struct {
	ChannelNames *StreamResponse_Names `protobuf:"bytes,6,opt,name=channel_names,json=channelNames,oneof"`
}
type StreamResponse_ChannelPart struct {
	ChannelPart *StreamResponse_Part `protobuf:"bytes,7,opt,name=channel_part,json=channelPart,oneof"`
}
type StreamResponse_UserNames struct {
	UserNames *StreamResponse_Users `protobuf:"bytes,8,opt,name=user_names,json=userNames,oneof"`
}
type StreamResponse_Message_ struct {
	Message *StreamResponse_Message `protobuf:"bytes,9,opt,name=message,oneof"`
}
type StreamResponse_Shutdown_ struct {
	Shutdown *StreamResponse_Shutdown `protobuf:"bytes,10,opt,name=shutdown,oneof"`
}

func (*StreamResponse_Error_) isStreamResponse_Event()       {}
func (*StreamResponse_Login_) isStreamResponse_Event()       {}
func (*StreamResponse_ChannelJoin) isStreamResponse_Event()  {}
func (*StreamResponse_ChannelNames) isStreamResponse_Event() {}
func (*StreamResponse_ChannelPart) isStreamResponse_Event()  {}
func (*StreamResponse_UserNames) isStreamResponse_Event()    {}
func (*StreamResponse_Message_) isStreamResponse_Event()     {}
func (*StreamResponse_Shutdown_) isStreamResponse_Event()    {}

func (m *StreamResponse) GetEvent() isStreamResponse_Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *StreamResponse) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *StreamResponse) GetTimestamp() *timestamp.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *StreamResponse) GetError() *StreamResponse_Error {
	if x, ok := m.GetEvent().(*StreamResponse_Error_); ok {
		return x.Error
	}
	return nil
}

func (m *StreamResponse) GetLogin() *StreamResponse_Login {
	if x, ok := m.GetEvent().(*StreamResponse_Login_); ok {
		return x.Login
	}
	return nil
}

func (m *StreamResponse) GetChannelJoin() *StreamResponse_Join {
	if x, ok := m.GetEvent().(*StreamResponse_ChannelJoin); ok {
		return x.ChannelJoin
	}
	return nil
}

func (m *StreamResponse) GetChannelNames() *StreamResponse_Names {
	if x, ok := m.GetEvent().(*StreamResponse_ChannelNames); ok {
		return x.ChannelNames
	}
	return nil
}

func (m *StreamResponse) GetChannelPart() *StreamResponse_Part {
	if x, ok := m.GetEvent().(*StreamResponse_ChannelPart); ok {
		return x.ChannelPart
	}
	return nil
}

func (m *StreamResponse) GetUserNames() *StreamResponse_Users {
	if x, ok := m.GetEvent().(*StreamResponse_UserNames); ok {
		return x.UserNames
	}
	return nil
}

func (m *StreamResponse) GetMessage() *StreamResponse_Message {
	if x, ok := m.GetEvent().(*StreamResponse_Message_); ok {
		return x.Message
	}
	return nil
}

func (m *StreamResponse) GetShutdown() *StreamResponse_Shutdown {
	if x, ok := m.GetEvent().(*StreamResponse_Shutdown_); ok {
		return x.Shutdown
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*StreamResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _StreamResponse_OneofMarshaler, _StreamResponse_OneofUnmarshaler, _StreamResponse_OneofSizer, []interface{}{
		(*StreamResponse_Error_)(nil),
		(*StreamResponse_Login_)(nil),
		(*StreamResponse_ChannelJoin)(nil),
		(*StreamResponse_ChannelNames)(nil),
		(*StreamResponse_ChannelPart)(nil),
		(*StreamResponse_UserNames)(nil),
		(*StreamResponse_Message_)(nil),
		(*StreamResponse_Shutdown_)(nil),
	}
}

func _StreamResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*StreamResponse)
	// event
	switch x := m.Event.(type) {
	case *StreamResponse_Error_:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Error); err != nil {
			return err
		}
	case *StreamResponse_Login_:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Login); err != nil {
			return err
		}
	case *StreamResponse_ChannelJoin:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelJoin); err != nil {
			return err
		}
	case *StreamResponse_ChannelNames:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelNames); err != nil {
			return err
		}
	case *StreamResponse_ChannelPart:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ChannelPart); err != nil {
			return err
		}
	case *StreamResponse_UserNames:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.UserNames); err != nil {
			return err
		}
	case *StreamResponse_Message_:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Message); err != nil {
			return err
		}
	case *StreamResponse_Shutdown_:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Shutdown); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("StreamResponse.Event has unexpected type %T", x)
	}
	return nil
}

func _StreamResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*StreamResponse)
	switch tag {
	case 3: // event.error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamResponse_Error)
		err := b.DecodeMessage(msg)
		m.Event = &StreamResponse_Error_{msg}
		return true, err
	case 4: // event.login
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamResponse_Login)
		err := b.DecodeMessage(msg)
		m.Event = &StreamResponse_Login_{msg}
		return true, err
	case 5: // event.channel_join
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamResponse_Join)
		err := b.DecodeMessage(msg)
		m.Event = &StreamResponse_ChannelJoin{msg}
		return true, err
	case 6: // event.channel_names
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamResponse_Names)
		err := b.DecodeMessage(msg)
		m.Event = &StreamResponse_ChannelNames{msg}
		return true, err
	case 7: // event.channel_part
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamResponse_Part)
		err := b.DecodeMessage(msg)
		m.Event = &StreamResponse_ChannelPart{msg}
		return true, err
	case 8: // event.user_names
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamResponse_Users)
		err := b.DecodeMessage(msg)
		m.Event = &StreamResponse_UserNames{msg}
		return true, err
	case 9: // event.message
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamResponse_Message)
		err := b.DecodeMessage(msg)
		m.Event = &StreamResponse_Message_{msg}
		return true, err
	case 10: // event.shutdown
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamResponse_Shutdown)
		err := b.DecodeMessage(msg)
		m.Event = &StreamResponse_Shutdown_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _StreamResponse_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*StreamResponse)
	// event
	switch x := m.Event.(type) {
	case *StreamResponse_Error_:
		s := proto.Size(x.Error)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamResponse_Login_:
		s := proto.Size(x.Login)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamResponse_ChannelJoin:
		s := proto.Size(x.ChannelJoin)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamResponse_ChannelNames:
		s := proto.Size(x.ChannelNames)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamResponse_ChannelPart:
		s := proto.Size(x.ChannelPart)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamResponse_UserNames:
		s := proto.Size(x.UserNames)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamResponse_Message_:
		s := proto.Size(x.Message)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StreamResponse_Shutdown_:
		s := proto.Size(x.Shutdown)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type StreamResponse_Error struct {
	Code                 int32    `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
	Message              string   `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamResponse_Error) Reset()         { *m = StreamResponse_Error{} }
func (m *StreamResponse_Error) String() string { return proto.CompactTextString(m) }
func (*StreamResponse_Error) ProtoMessage()    {}
func (*StreamResponse_Error) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1, 0}
}
func (m *StreamResponse_Error) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse_Error.Unmarshal(m, b)
}
func (m *StreamResponse_Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse_Error.Marshal(b, m, deterministic)
}
func (dst *StreamResponse_Error) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse_Error.Merge(dst, src)
}
func (m *StreamResponse_Error) XXX_Size() int {
	return xxx_messageInfo_StreamResponse_Error.Size(m)
}
func (m *StreamResponse_Error) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse_Error.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse_Error proto.InternalMessageInfo

func (m *StreamResponse_Error) GetCode() int32 {
	if m != nil {
		return m.Code
	}
	return 0
}

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

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

func (m *StreamResponse_Login) Reset()         { *m = StreamResponse_Login{} }
func (m *StreamResponse_Login) String() string { return proto.CompactTextString(m) }
func (*StreamResponse_Login) ProtoMessage()    {}
func (*StreamResponse_Login) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1, 1}
}
func (m *StreamResponse_Login) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse_Login.Unmarshal(m, b)
}
func (m *StreamResponse_Login) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse_Login.Marshal(b, m, deterministic)
}
func (dst *StreamResponse_Login) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse_Login.Merge(dst, src)
}
func (m *StreamResponse_Login) XXX_Size() int {
	return xxx_messageInfo_StreamResponse_Login.Size(m)
}
func (m *StreamResponse_Login) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse_Login.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse_Login proto.InternalMessageInfo

func (m *StreamResponse_Login) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

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

func (m *StreamResponse_Join) Reset()         { *m = StreamResponse_Join{} }
func (m *StreamResponse_Join) String() string { return proto.CompactTextString(m) }
func (*StreamResponse_Join) ProtoMessage()    {}
func (*StreamResponse_Join) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1, 2}
}
func (m *StreamResponse_Join) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse_Join.Unmarshal(m, b)
}
func (m *StreamResponse_Join) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse_Join.Marshal(b, m, deterministic)
}
func (dst *StreamResponse_Join) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse_Join.Merge(dst, src)
}
func (m *StreamResponse_Join) XXX_Size() int {
	return xxx_messageInfo_StreamResponse_Join.Size(m)
}
func (m *StreamResponse_Join) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse_Join.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse_Join proto.InternalMessageInfo

func (m *StreamResponse_Join) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

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

func (m *StreamResponse_Part) Reset()         { *m = StreamResponse_Part{} }
func (m *StreamResponse_Part) String() string { return proto.CompactTextString(m) }
func (*StreamResponse_Part) ProtoMessage()    {}
func (*StreamResponse_Part) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1, 3}
}
func (m *StreamResponse_Part) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse_Part.Unmarshal(m, b)
}
func (m *StreamResponse_Part) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse_Part.Marshal(b, m, deterministic)
}
func (dst *StreamResponse_Part) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse_Part.Merge(dst, src)
}
func (m *StreamResponse_Part) XXX_Size() int {
	return xxx_messageInfo_StreamResponse_Part.Size(m)
}
func (m *StreamResponse_Part) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse_Part.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse_Part proto.InternalMessageInfo

func (m *StreamResponse_Part) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

type StreamResponse_Names struct {
	Channel              string                 `protobuf:"bytes,1,opt,name=channel" json:"channel,omitempty"`
	Users                []*StreamResponse_User `protobuf:"bytes,2,rep,name=users" json:"users,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *StreamResponse_Names) Reset()         { *m = StreamResponse_Names{} }
func (m *StreamResponse_Names) String() string { return proto.CompactTextString(m) }
func (*StreamResponse_Names) ProtoMessage()    {}
func (*StreamResponse_Names) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1, 4}
}
func (m *StreamResponse_Names) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse_Names.Unmarshal(m, b)
}
func (m *StreamResponse_Names) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse_Names.Marshal(b, m, deterministic)
}
func (dst *StreamResponse_Names) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse_Names.Merge(dst, src)
}
func (m *StreamResponse_Names) XXX_Size() int {
	return xxx_messageInfo_StreamResponse_Names.Size(m)
}
func (m *StreamResponse_Names) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse_Names.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse_Names proto.InternalMessageInfo

func (m *StreamResponse_Names) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

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

type StreamResponse_Users struct {
	Users                []*StreamResponse_User `protobuf:"bytes,1,rep,name=users" json:"users,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *StreamResponse_Users) Reset()         { *m = StreamResponse_Users{} }
func (m *StreamResponse_Users) String() string { return proto.CompactTextString(m) }
func (*StreamResponse_Users) ProtoMessage()    {}
func (*StreamResponse_Users) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1, 5}
}
func (m *StreamResponse_Users) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse_Users.Unmarshal(m, b)
}
func (m *StreamResponse_Users) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse_Users.Marshal(b, m, deterministic)
}
func (dst *StreamResponse_Users) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse_Users.Merge(dst, src)
}
func (m *StreamResponse_Users) XXX_Size() int {
	return xxx_messageInfo_StreamResponse_Users.Size(m)
}
func (m *StreamResponse_Users) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse_Users.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse_Users proto.InternalMessageInfo

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

type StreamResponse_User struct {
	Id                   uint64   `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamResponse_User) Reset()         { *m = StreamResponse_User{} }
func (m *StreamResponse_User) String() string { return proto.CompactTextString(m) }
func (*StreamResponse_User) ProtoMessage()    {}
func (*StreamResponse_User) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1, 6}
}
func (m *StreamResponse_User) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse_User.Unmarshal(m, b)
}
func (m *StreamResponse_User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse_User.Marshal(b, m, deterministic)
}
func (dst *StreamResponse_User) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse_User.Merge(dst, src)
}
func (m *StreamResponse_User) XXX_Size() int {
	return xxx_messageInfo_StreamResponse_User.Size(m)
}
func (m *StreamResponse_User) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse_User.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse_User proto.InternalMessageInfo

func (m *StreamResponse_User) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

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

type StreamResponse_Message struct {
	Channel              string   `protobuf:"bytes,1,opt,name=channel" json:"channel,omitempty"`
	Message              string   `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamResponse_Message) Reset()         { *m = StreamResponse_Message{} }
func (m *StreamResponse_Message) String() string { return proto.CompactTextString(m) }
func (*StreamResponse_Message) ProtoMessage()    {}
func (*StreamResponse_Message) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1, 7}
}
func (m *StreamResponse_Message) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse_Message.Unmarshal(m, b)
}
func (m *StreamResponse_Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse_Message.Marshal(b, m, deterministic)
}
func (dst *StreamResponse_Message) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse_Message.Merge(dst, src)
}
func (m *StreamResponse_Message) XXX_Size() int {
	return xxx_messageInfo_StreamResponse_Message.Size(m)
}
func (m *StreamResponse_Message) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse_Message.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse_Message proto.InternalMessageInfo

func (m *StreamResponse_Message) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

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

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

func (m *StreamResponse_Shutdown) Reset()         { *m = StreamResponse_Shutdown{} }
func (m *StreamResponse_Shutdown) String() string { return proto.CompactTextString(m) }
func (*StreamResponse_Shutdown) ProtoMessage()    {}
func (*StreamResponse_Shutdown) Descriptor() ([]byte, []int) {
	return fileDescriptor_chat_5d1937391afcaa39, []int{1, 8}
}
func (m *StreamResponse_Shutdown) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamResponse_Shutdown.Unmarshal(m, b)
}
func (m *StreamResponse_Shutdown) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamResponse_Shutdown.Marshal(b, m, deterministic)
}
func (dst *StreamResponse_Shutdown) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse_Shutdown.Merge(dst, src)
}
func (m *StreamResponse_Shutdown) XXX_Size() int {
	return xxx_messageInfo_StreamResponse_Shutdown.Size(m)
}
func (m *StreamResponse_Shutdown) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse_Shutdown.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse_Shutdown proto.InternalMessageInfo

func init() {
	proto.RegisterType((*StreamRequest)(nil), "chat.StreamRequest")
	proto.RegisterType((*StreamRequest_Login)(nil), "chat.StreamRequest.Login")
	proto.RegisterType((*StreamRequest_Join)(nil), "chat.StreamRequest.Join")
	proto.RegisterType((*StreamRequest_Part)(nil), "chat.StreamRequest.Part")
	proto.RegisterType((*StreamRequest_Message)(nil), "chat.StreamRequest.Message")
	proto.RegisterType((*StreamRequest_Quit)(nil), "chat.StreamRequest.Quit")
	proto.RegisterType((*StreamResponse)(nil), "chat.StreamResponse")
	proto.RegisterType((*StreamResponse_Error)(nil), "chat.StreamResponse.Error")
	proto.RegisterType((*StreamResponse_Login)(nil), "chat.StreamResponse.Login")
	proto.RegisterType((*StreamResponse_Join)(nil), "chat.StreamResponse.Join")
	proto.RegisterType((*StreamResponse_Part)(nil), "chat.StreamResponse.Part")
	proto.RegisterType((*StreamResponse_Names)(nil), "chat.StreamResponse.Names")
	proto.RegisterType((*StreamResponse_Users)(nil), "chat.StreamResponse.Users")
	proto.RegisterType((*StreamResponse_User)(nil), "chat.StreamResponse.User")
	proto.RegisterType((*StreamResponse_Message)(nil), "chat.StreamResponse.Message")
	proto.RegisterType((*StreamResponse_Shutdown)(nil), "chat.StreamResponse.Shutdown")
}

// 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

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

type chatClient struct {
	cc *grpc.ClientConn
}

func NewChatClient(cc *grpc.ClientConn) ChatClient {
	return &chatClient{cc}
}

func (c *chatClient) Stream(ctx context.Context, opts ...grpc.CallOption) (Chat_StreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Chat_serviceDesc.Streams[0], "/chat.Chat/Stream", opts...)
	if err != nil {
		return nil, err
	}
	x := &chatStreamClient{stream}
	return x, nil
}

type Chat_StreamClient interface {
	Send(*StreamRequest) error
	Recv() (*StreamResponse, error)
	grpc.ClientStream
}

type chatStreamClient struct {
	grpc.ClientStream
}

func (x *chatStreamClient) Send(m *StreamRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

// ChatServer is the server API for Chat service.
type ChatServer interface {
	Stream(Chat_StreamServer) error
}

func RegisterChatServer(s *grpc.Server, srv ChatServer) {
	s.RegisterService(&_Chat_serviceDesc, srv)
}

func _Chat_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ChatServer).Stream(&chatStreamServer{stream})
}

type Chat_StreamServer interface {
	Send(*StreamResponse) error
	Recv() (*StreamRequest, error)
	grpc.ServerStream
}

type chatStreamServer struct {
	grpc.ServerStream
}

func (x *chatStreamServer) Send(m *StreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *chatStreamServer) Recv() (*StreamRequest, error) {
	m := new(StreamRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _Chat_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chat.Chat",
	HandlerType: (*ChatServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Stream",
			Handler:       _Chat_Stream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "sam/chat/chat.proto",
}

func init() { proto.RegisterFile("sam/chat/chat.proto", fileDescriptor_chat_5d1937391afcaa39) }

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