func (mr *MockByteStream_WriteClientMockRecorder) CloseSend() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockByteStream_WriteClient)(nil).CloseSend))
}
CloseSend indicates an expected call of CloseSend
package mock_bytestream
import (
	context "context"
	gomock "github.com/golang/mock/gomock"
	bytestream "google.golang.org/genproto/googleapis/bytestream"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
	reflect "reflect"
)
type MockByteStreamClient struct {
	ctrl     *gomock.Controller
	recorder *MockByteStreamClientMockRecorder
}
type MockByteStreamClientMockRecorder struct {
	mock *MockByteStreamClient
}
func NewMockByteStreamClient(ctrl *gomock.Controller) *MockByteStreamClient {
	mock := &MockByteStreamClient{ctrl: ctrl}
	mock.recorder = &MockByteStreamClientMockRecorder{mock}
	return mock
}
func (m *MockByteStreamClient) EXPECT() *MockByteStreamClientMockRecorder {
	return m.recorder
}
func (m *MockByteStreamClient) QueryWriteStatus(arg0 context.Context, arg1 *bytestream.QueryWriteStatusRequest, arg2 ...grpc.CallOption) (*bytestream.QueryWriteStatusResponse, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryWriteStatus", varargs...)
	ret0, _ := ret[0].(*bytestream.QueryWriteStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockByteStreamClientMockRecorder) QueryWriteStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWriteStatus", reflect.TypeOf((*MockByteStreamClient)(nil).QueryWriteStatus), varargs...)
}
func (m *MockByteStreamClient) Read(arg0 context.Context, arg1 *bytestream.ReadRequest, arg2 ...grpc.CallOption) (bytestream.ByteStream_ReadClient, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Read", varargs...)
	ret0, _ := ret[0].(bytestream.ByteStream_ReadClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockByteStreamClientMockRecorder) Read(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockByteStreamClient)(nil).Read), varargs...)
}
func (m *MockByteStreamClient) Write(arg0 context.Context, arg1 ...grpc.CallOption) (bytestream.ByteStream_WriteClient, error) {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Write", varargs...)
	ret0, _ := ret[0].(bytestream.ByteStream_WriteClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockByteStreamClientMockRecorder) Write(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockByteStreamClient)(nil).Write), varargs...)
}
type MockByteStream_ReadClient struct {
	ctrl     *gomock.Controller
	recorder *MockByteStream_ReadClientMockRecorder
}
type MockByteStream_ReadClientMockRecorder struct {
	mock *MockByteStream_ReadClient
}
func NewMockByteStream_ReadClient(ctrl *gomock.Controller) *MockByteStream_ReadClient {
	mock := &MockByteStream_ReadClient{ctrl: ctrl}
	mock.recorder = &MockByteStream_ReadClientMockRecorder{mock}
	return mock
}
func (m *MockByteStream_ReadClient) EXPECT() *MockByteStream_ReadClientMockRecorder {
	return m.recorder
}
func (m *MockByteStream_ReadClient) CloseSend() error {
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockByteStream_ReadClientMockRecorder) CloseSend() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockByteStream_ReadClient)(nil).CloseSend))
}
func (m *MockByteStream_ReadClient) Context() context.Context {
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}
func (mr *MockByteStream_ReadClientMockRecorder) Context() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockByteStream_ReadClient)(nil).Context))
}
func (m *MockByteStream_ReadClient) Header() (metadata.MD, error) {
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockByteStream_ReadClientMockRecorder) Header() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockByteStream_ReadClient)(nil).Header))
}
func (m *MockByteStream_ReadClient) Recv() (*bytestream.ReadResponse, error) {
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*bytestream.ReadResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockByteStream_ReadClientMockRecorder) Recv() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockByteStream_ReadClient)(nil).Recv))
}
func (m *MockByteStream_ReadClient) RecvMsg(arg0 interface{}) error {
	ret := m.ctrl.Call(m, "RecvMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockByteStream_ReadClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockByteStream_ReadClient)(nil).RecvMsg), arg0)
}
func (m *MockByteStream_ReadClient) SendMsg(arg0 interface{}) error {
	ret := m.ctrl.Call(m, "SendMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockByteStream_ReadClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockByteStream_ReadClient)(nil).SendMsg), arg0)
}
func (m *MockByteStream_ReadClient) Trailer() metadata.MD {
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}
func (mr *MockByteStream_ReadClientMockRecorder) Trailer() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockByteStream_ReadClient)(nil).Trailer))
}
type MockByteStream_WriteClient struct {
	ctrl     *gomock.Controller
	recorder *MockByteStream_WriteClientMockRecorder
}
type MockByteStream_WriteClientMockRecorder struct {
	mock *MockByteStream_WriteClient
}
func NewMockByteStream_WriteClient(ctrl *gomock.Controller) *MockByteStream_WriteClient {
	mock := &MockByteStream_WriteClient{ctrl: ctrl}
	mock.recorder = &MockByteStream_WriteClientMockRecorder{mock}
	return mock
}
func (m *MockByteStream_WriteClient) EXPECT() *MockByteStream_WriteClientMockRecorder {
	return m.recorder
}
func (m *MockByteStream_WriteClient) CloseAndRecv() (*bytestream.WriteResponse, error) {
	ret := m.ctrl.Call(m, "CloseAndRecv")
	ret0, _ := ret[0].(*bytestream.WriteResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockByteStream_WriteClientMockRecorder) CloseAndRecv() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAndRecv", reflect.TypeOf((*MockByteStream_WriteClient)(nil).CloseAndRecv))
}
func (m *MockByteStream_WriteClient) CloseSend() error {
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}