// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anyproto/any-sync/commonspace/sync/syncdeps (interfaces: ObjectSyncHandler,RequestSender,ResponseCollector)
//
// Generated by this command:
//
//	mockgen -destination mock_syncdeps/mock_syncdeps.go github.com/anyproto/any-sync/commonspace/sync/syncdeps ObjectSyncHandler,RequestSender,ResponseCollector
//

// Package mock_syncdeps is a generated GoMock package.
package mock_syncdeps

import (
	context "context"
	reflect "reflect"

	syncdeps "github.com/anyproto/any-sync/commonspace/sync/syncdeps"
	syncstatus "github.com/anyproto/any-sync/commonspace/syncstatus"
	gomock "go.uber.org/mock/gomock"
	proto "google.golang.org/protobuf/proto"
	drpc "storj.io/drpc"
)

// MockObjectSyncHandler is a mock of ObjectSyncHandler interface.
type MockObjectSyncHandler struct {
	ctrl     *gomock.Controller
	recorder *MockObjectSyncHandlerMockRecorder
	isgomock struct{}
}

// MockObjectSyncHandlerMockRecorder is the mock recorder for MockObjectSyncHandler.
type MockObjectSyncHandlerMockRecorder struct {
	mock *MockObjectSyncHandler
}

// NewMockObjectSyncHandler creates a new mock instance.
func NewMockObjectSyncHandler(ctrl *gomock.Controller) *MockObjectSyncHandler {
	mock := &MockObjectSyncHandler{ctrl: ctrl}
	mock.recorder = &MockObjectSyncHandlerMockRecorder{mock}
	return mock
}

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

// HandleHeadUpdate mocks base method.
func (m *MockObjectSyncHandler) HandleHeadUpdate(ctx context.Context, statusUpdater syncstatus.StatusUpdater, headUpdate drpc.Message) (syncdeps.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleHeadUpdate", ctx, statusUpdater, headUpdate)
	ret0, _ := ret[0].(syncdeps.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleHeadUpdate indicates an expected call of HandleHeadUpdate.
func (mr *MockObjectSyncHandlerMockRecorder) HandleHeadUpdate(ctx, statusUpdater, headUpdate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleHeadUpdate", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleHeadUpdate), ctx, statusUpdater, headUpdate)
}

// HandleResponse mocks base method.
func (m *MockObjectSyncHandler) HandleResponse(ctx context.Context, peerId, objectId string, resp syncdeps.Response) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleResponse", ctx, peerId, objectId, resp)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleResponse indicates an expected call of HandleResponse.
func (mr *MockObjectSyncHandlerMockRecorder) HandleResponse(ctx, peerId, objectId, resp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResponse", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleResponse), ctx, peerId, objectId, resp)
}

// HandleStreamRequest mocks base method.
func (m *MockObjectSyncHandler) HandleStreamRequest(ctx context.Context, rq syncdeps.Request, updater syncdeps.QueueSizeUpdater, send func(proto.Message) error) (syncdeps.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleStreamRequest", ctx, rq, updater, send)
	ret0, _ := ret[0].(syncdeps.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleStreamRequest indicates an expected call of HandleStreamRequest.
func (mr *MockObjectSyncHandlerMockRecorder) HandleStreamRequest(ctx, rq, updater, send any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamRequest", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleStreamRequest), ctx, rq, updater, send)
}

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

// ResponseCollector indicates an expected call of ResponseCollector.
func (mr *MockObjectSyncHandlerMockRecorder) ResponseCollector() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResponseCollector", reflect.TypeOf((*MockObjectSyncHandler)(nil).ResponseCollector))
}

// MockRequestSender is a mock of RequestSender interface.
type MockRequestSender struct {
	ctrl     *gomock.Controller
	recorder *MockRequestSenderMockRecorder
	isgomock struct{}
}

// MockRequestSenderMockRecorder is the mock recorder for MockRequestSender.
type MockRequestSenderMockRecorder struct {
	mock *MockRequestSender
}

// NewMockRequestSender creates a new mock instance.
func NewMockRequestSender(ctrl *gomock.Controller) *MockRequestSender {
	mock := &MockRequestSender{ctrl: ctrl}
	mock.recorder = &MockRequestSenderMockRecorder{mock}
	return mock
}

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

// SendRequest mocks base method.
func (m *MockRequestSender) SendRequest(ctx context.Context, rq syncdeps.Request, collector syncdeps.ResponseCollector) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendRequest", ctx, rq, collector)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendRequest indicates an expected call of SendRequest.
func (mr *MockRequestSenderMockRecorder) SendRequest(ctx, rq, collector any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRequest", reflect.TypeOf((*MockRequestSender)(nil).SendRequest), ctx, rq, collector)
}

// MockResponseCollector is a mock of ResponseCollector interface.
type MockResponseCollector struct {
	ctrl     *gomock.Controller
	recorder *MockResponseCollectorMockRecorder
	isgomock struct{}
}

// MockResponseCollectorMockRecorder is the mock recorder for MockResponseCollector.
type MockResponseCollectorMockRecorder struct {
	mock *MockResponseCollector
}

// NewMockResponseCollector creates a new mock instance.
func NewMockResponseCollector(ctrl *gomock.Controller) *MockResponseCollector {
	mock := &MockResponseCollector{ctrl: ctrl}
	mock.recorder = &MockResponseCollectorMockRecorder{mock}
	return mock
}

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

// CollectResponse mocks base method.
func (m *MockResponseCollector) CollectResponse(ctx context.Context, peerId, objectId string, resp syncdeps.Response) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CollectResponse", ctx, peerId, objectId, resp)
	ret0, _ := ret[0].(error)
	return ret0
}

// CollectResponse indicates an expected call of CollectResponse.
func (mr *MockResponseCollectorMockRecorder) CollectResponse(ctx, peerId, objectId, resp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectResponse", reflect.TypeOf((*MockResponseCollector)(nil).CollectResponse), ctx, peerId, objectId, resp)
}

// NewResponse mocks base method.
func (m *MockResponseCollector) NewResponse() syncdeps.Response {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewResponse")
	ret0, _ := ret[0].(syncdeps.Response)
	return ret0
}

// NewResponse indicates an expected call of NewResponse.
func (mr *MockResponseCollectorMockRecorder) NewResponse() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewResponse", reflect.TypeOf((*MockResponseCollector)(nil).NewResponse))
}
