// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ydb-platform/ydb-go-sdk/v3/internal/topic/topicwriterinternal (interfaces: RawTopicWriterStream)
//
// Generated by this command:
//
//	mockgen -destination raw_topic_writer_stream_mock_test.go --typed -package topicwriterinternal -write_package_comment=false github.com/ydb-platform/ydb-go-sdk/v3/internal/topic/topicwriterinternal RawTopicWriterStream
package topicwriterinternal

import (
	reflect "reflect"

	endpoint "github.com/ydb-platform/ydb-go-sdk/v3/internal/endpoint"
	rawtopicwriter "github.com/ydb-platform/ydb-go-sdk/v3/internal/grpcwrapper/rawtopic/rawtopicwriter"
	gomock "go.uber.org/mock/gomock"
)

// MockRawTopicWriterStream is a mock of RawTopicWriterStream interface.
type MockRawTopicWriterStream struct {
	ctrl     *gomock.Controller
	recorder *MockRawTopicWriterStreamMockRecorder
}

// MockRawTopicWriterStreamMockRecorder is the mock recorder for MockRawTopicWriterStream.
type MockRawTopicWriterStreamMockRecorder struct {
	mock *MockRawTopicWriterStream
}

// NewMockRawTopicWriterStream creates a new mock instance.
func NewMockRawTopicWriterStream(ctrl *gomock.Controller) *MockRawTopicWriterStream {
	mock := &MockRawTopicWriterStream{ctrl: ctrl}
	mock.recorder = &MockRawTopicWriterStreamMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRawTopicWriterStream) EXPECT() *MockRawTopicWriterStreamMockRecorder {
	return m.recorder
}

// CloseSend mocks base method.
func (m *MockRawTopicWriterStream) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockRawTopicWriterStreamMockRecorder) CloseSend() *MockRawTopicWriterStreamCloseSendCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockRawTopicWriterStream)(nil).CloseSend))
	return &MockRawTopicWriterStreamCloseSendCall{Call: call}
}

// MockRawTopicWriterStreamCloseSendCall wrap *gomock.Call
type MockRawTopicWriterStreamCloseSendCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRawTopicWriterStreamCloseSendCall) Return(arg0 error) *MockRawTopicWriterStreamCloseSendCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRawTopicWriterStreamCloseSendCall) Do(f func() error) *MockRawTopicWriterStreamCloseSendCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRawTopicWriterStreamCloseSendCall) DoAndReturn(f func() error) *MockRawTopicWriterStreamCloseSendCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Endpoint mocks base method.
func (m *MockRawTopicWriterStream) Endpoint() endpoint.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Endpoint")
	ret0, _ := ret[0].(endpoint.Endpoint)
	return ret0
}

// Endpoint indicates an expected call of Endpoint.
func (mr *MockRawTopicWriterStreamMockRecorder) Endpoint() *MockRawTopicWriterStreamEndpointCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Endpoint", reflect.TypeOf((*MockRawTopicWriterStream)(nil).Endpoint))
	return &MockRawTopicWriterStreamEndpointCall{Call: call}
}

// MockRawTopicWriterStreamEndpointCall wrap *gomock.Call
type MockRawTopicWriterStreamEndpointCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRawTopicWriterStreamEndpointCall) Return(arg0 endpoint.Endpoint) *MockRawTopicWriterStreamEndpointCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRawTopicWriterStreamEndpointCall) Do(f func() endpoint.Endpoint) *MockRawTopicWriterStreamEndpointCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRawTopicWriterStreamEndpointCall) DoAndReturn(f func() endpoint.Endpoint) *MockRawTopicWriterStreamEndpointCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Recv mocks base method.
func (m *MockRawTopicWriterStream) Recv() (rawtopicwriter.ServerMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(rawtopicwriter.ServerMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockRawTopicWriterStreamMockRecorder) Recv() *MockRawTopicWriterStreamRecvCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockRawTopicWriterStream)(nil).Recv))
	return &MockRawTopicWriterStreamRecvCall{Call: call}
}

// MockRawTopicWriterStreamRecvCall wrap *gomock.Call
type MockRawTopicWriterStreamRecvCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRawTopicWriterStreamRecvCall) Return(arg0 rawtopicwriter.ServerMessage, arg1 error) *MockRawTopicWriterStreamRecvCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRawTopicWriterStreamRecvCall) Do(f func() (rawtopicwriter.ServerMessage, error)) *MockRawTopicWriterStreamRecvCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRawTopicWriterStreamRecvCall) DoAndReturn(f func() (rawtopicwriter.ServerMessage, error)) *MockRawTopicWriterStreamRecvCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Send mocks base method.
func (m *MockRawTopicWriterStream) Send(arg0 rawtopicwriter.ClientMessage) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockRawTopicWriterStreamMockRecorder) Send(arg0 any) *MockRawTopicWriterStreamSendCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockRawTopicWriterStream)(nil).Send), arg0)
	return &MockRawTopicWriterStreamSendCall{Call: call}
}

// MockRawTopicWriterStreamSendCall wrap *gomock.Call
type MockRawTopicWriterStreamSendCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRawTopicWriterStreamSendCall) Return(arg0 error) *MockRawTopicWriterStreamSendCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRawTopicWriterStreamSendCall) Do(f func(rawtopicwriter.ClientMessage) error) *MockRawTopicWriterStreamSendCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRawTopicWriterStreamSendCall) DoAndReturn(f func(rawtopicwriter.ClientMessage) error) *MockRawTopicWriterStreamSendCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
